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

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

VxWorks

开发平台：

C/C++

sysLib.c：源码内容
  1. /* sysLib.c - IDT 79PMC438 system-dependent routines */
  3. /* Copyright 1984-2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * This file has been developed or significantly modified by the
  8.  * MIPS Center of Excellence Dedicated Engineering Staff.
  9.  * This notice is as per the MIPS Center of Excellence Master Partner
  10.  * Agreement, do not remove this notice without checking first with
  11.  * WR/Platforms MIPS Center of Excellence engineering management.
  12.  */
  14. /*
  15. modification history
  16. --------------------
  17. 01a,02jun02,krao    adapted to  79PMC438 board
  19. */
  21. /*
  22. DESCRIPTION
  23. This library provides board-specific routines for the IDT79PMC438 board.
  26. INCLUDE FILES: sysLib.h
  28. SEE ALSO:
  29. .pG "Configuration"
  30. */
  32. /* includes */
  34. #include "vxWorks.h"
  35. #include "vxLib.h"
  36. #include "config.h"
  37. #include "version.h"
  38. #include "arch/mips/cacheMipsLib.h"
  39. #include "arch/mips/ivMips.h"
  40. #include "arch/mips/esfMips.h"
  41. #include "sysLib.h"
  42. #include "string.h"
  43. #include "intLib.h"
  44. #include "logLib.h"
  45. #include "rc32438.h"
  46. #include "sysI2CDrv.h"
  48. #ifdef BROADCOM_BSP
  50. #include "netinet/in.h"     /* for sysBindFix() */
  51. #include "sockLib.h"        /* for sysBindFix() */
  53. #include "symLib.h"
  54. #ifdef INCLUDE_PCI
  55. int sysPCIBridgeProbe(int instance,
  56.       int primary,
  57.       int secondary,
  58.       int subordinate);
  59. #endif
  60. #endif /*!BROADCOM_BSP */
  62. #ifdef INCLUDE_IDT_END
  63. #include "end.h"
  64. #include "netBufLib.h"
  65. #include "idt32438End.h"
  66. #endif
  68. /* externs */
  70. IMPORT void     sys557PciInit (void);
  71. IMPORT void     sysWbFlush ();
  72. IMPORT ULONG    taskSRInit ();
  73. IMPORT void     sysClearTlbEntry ();
  74. IMPORT int      sysCompareSet ();
  75. IMPORT int      sysCompareGet ();
  76. IMPORT int      sysPridGet ();
  77. IMPORT int      sysCountGet ();
  78. IMPORT int      sysCountSet ();
  79. IMPORT int      sysConfig1Get ();
  80. IMPORT void     sysPciBusErrEnable ();
  81. IMPORT void     sysPciBusErrDisable ();
  82. IMPORT void     sysRc32438ClkEnable ();
  83. IMPORT void     sysRc32438ClkDisable ();
  84.  
  87. IMPORT UINT8    ffsMsbTbl[];            /* Msb high interrupt hash table */
  88. IMPORT UINT8    ffsLsbTbl[];            /* Lsb high interrupt hash table */
  89. IMPORT int      printf (const char *, ...);
  90. IMPORT int      isprint (char);
  92. /* cache initialization */
  94. IMPORT STATUS   cache4kcLibInit(CACHE_MODE, CACHE_MODE, 
  95.                                 UINT32, UINT32, UINT32, UINT32);
  96. /*defines */
  98. #define WAIT(x) { volatile int iCount=0; while (++iCount < (x)) ; }
  99. /*
  100.  * Override max # PCI buses to optimize pciFindDevice
  101.  * and PCI auto-config.
  102.  */
  103.  
  105. /* Timer defines */ 
  107. #define TIMER_ENABLE  1
  108. #define TIMER_DISABLE 0
  110. /*typedef */
  112. typedef struct priotable
  113.     {
  114.     ULONG   intCause;       /* cause of interrupt   */
  115.     ULONG   bsrTableOffset; /* index to BSR table   */
  116.     ULONG   statusReg;      /* interrupt level  */
  117.     ULONG   pad;            /* pad for ease of use  */
  118.     } PRIO_TABLE;
  120. /*globals */
  121.  
  122. /*
  123.  * Interrupt demux routine for RC32438 internal devices - This must be
  124.  * defined here even though it's not global. It's used in the
  125.  * intPrioTable below.
  126.  */
  127.  
  128. LOCAL ULONG sysRc32438IntDemux (int arg);
  129. LOCAL ULONG sysRc32438GpioDemux (int arg);
  130. LOCAL BOOL  sysIsPciMapped (ULONG address);
  131. LOCAL void  sysClkInt ();    
  132. LOCAL ULONG sysTimerIsr (int arg); 
  134. /* GLOBAL - Timer handlers */
  136. FUNCPTR sysTimer0Routine             = NULL;
  137. FUNCPTR sysTimer1Routine             = NULL;
  138. FUNCPTR sysTimer2Routine             = NULL;
  139. FUNCPTR sysRefreshTimerRoutine       = NULL;
  140. FUNCPTR sysWatchdogTimerRoutine      = NULL;
  141. FUNCPTR sysUndecodedCPUWriteRoutine  = NULL;
  142. ULONG   sysSoftCompare            = 0;      /* last target compare reg value */
  144. /*
  145.  *       intPrioTable is a board dependant structure that aids in the
  146.  *       processing of the 8 Rc32438 interrupt conditions.
  147.  *       It is used by excLib to determine the pending interrupt and
  148.  *       to call the user attached handler.  The present search algorithm
  149.  *       relies on a one to one mapping of Rc32438 interrupt lines and
  150.  *       table entries. 
  151.  *
  152.  *       Each entry has 4 fields, the first (intCause) is the interrupt ID, 
  153.  *       second (bsrTableOffset) is the vector number, third is unused
  154.  *       last (pad) is the multiplex field.  When an interrupt is received
  155.  *       the handler maps the pending Rc32438 line to  its' corresponding
  156.  *       table entry (ie. Software interrupt 0 would map to the first entry
  157.  *       in the table).  At this point interrupts that are not pending are
  158.  *       enabled.  Next the multiplex field is read, if it is zero, field 
  159.  *       two is taken as the interrupt vector number in the BSR table, 
  160.  *       otherwise it is interpreted as a demultiplex function and called
  161.  *       with field 4 passed as it's parameter.  The job of the demultiplex
  162.  *       routine is to calculate the correct interrupt vector number and pass
  163.  *       it back to the handler.  The handler can then call the routine the
  164.  *       user has installed in the BSR table with intVecSet, or intConnect.
  165.  *
  166.  *       This table is critical to interrupt processing.  Do not alter
  167.  *       it's contents until you understand the consequences.  The routine
  168.  *       sysPrioUpdate can aid modification during runtime.
  169.  */
  171. PRIO_TABLE intPrioTable[8] =
  172.     {
  173.     {CAUSE_SW1,(ULONG) IV_SWTRAP0_VEC,     0x0100, 0},      /* sw trap 0      */
  174.     {CAUSE_SW2,(ULONG) IV_SWTRAP1_VEC,     0x0200, 0},      /* sw trap 1      */
  175.     {CAUSE_IP3,(ULONG) sysTimerIsr,        0x8000, 1},      /* IRQ0           */
  176.     {CAUSE_IP4,(ULONG) INT_VEC_GRP3,       0x0800, 0},      /* IRQ1           */
  177.     {CAUSE_IP5,(ULONG) INT_VEC_GRP4,       0x1000, 0},      /* IRQ2           */
  178.     {CAUSE_IP6,(ULONG) sysRc32438IntDemux, 0x2000, 1},      /* IRQ3           */
  179.     {CAUSE_IP7,(ULONG) sysRc32438GpioDemux,0x4000, 1},      /* IRQ4           */
  180.     {CAUSE_IP8,(ULONG) INT_VEC_GRP7,       0x0400, 0}       /* IRQ5           */
  181.     };
  183. /*
  184.  *  Since tying interrupt lines to the processor is board dependent sysHashOrder
  185.  *  is provided to select the prioritization of interrupt lines.  Setting the
  186.  *  #define INT_PRIO_MSB to TRUE prioritizes interrupts from 7-0, 7 being
  187.  *  highest priority, 0 being lowest.  Setting it to FALSE prioritizes
  188.  *  interrupts from 0-7.  See idt79pmc438.h for the definition of INT_PRIO_MSB.
  189.  */
  191. #if (INT_PRIO_MSB == TRUE)
  192.     UINT8 * sysHashOrder = ffsMsbTbl;   /* interrupt prio., 7 = high 0 = low */
  193. #else   /* INT_PRIO_MSB == TRUE */
  194.     UINT8 * sysHashOrder = ffsLsbTbl;   /* interrupt prio., 0 = high 7 = low */
  195. #endif  /* INT_PRIO_MSB == TRUE */
  198. /*locals */
  200. int sysMemTopDebug = 0;
  202. typedef struct dma_int_vect
  203.     {
  204.     void *  func;   /* pointer to interrupt service routine */
  205.     void *  param;  /* parameter passed to interrupt service routine */
  206.     } DMA_INT_VECT;
  208. LOCAL DMA_INT_VECT  dmaInterruptVectors [MAX_DMA_INTRS];
  209.                                                /* DMA interrupt vector table */
  211. volatile unsigned char *ptr;
  213. #if defined (AUTO_CACHE_DETECT)
  214.     LOCAL int cacheSize[] = { 64, 128, 256, 512, 1024, 2048, 4096, 0 };
  215.     LOCAL int cacheLineSize[] = { 0, 4, 8, 16, 32, 64, 128, 0 };
  216.     LOCAL int cacheAssoc[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
  217. #endif
  220. LOCAL BOOL      sysAuxClkRunning        = FALSE; /* aux clock enabled flag    */
  221. LOCAL BOOL      sysAuxClkConnected      = FALSE; /* aux clock connect flag    */
  222. LOCAL int       sysAuxClkTicksPerSecond = 100  ; /* aux timer rate            */
  223. LOCAL int       sysAuxClkArg            = 0    ; /* aux clock int routine arg */
  224. LOCAL FUNCPTR   sysAuxClkRoutine        = NULL ; /* aux clock interpt routine */
  226. /* locals */
  228. LOCAL int   sysClkTicksPerSecond    = 100  ;    /* default sys timer rate     */
  229. LOCAL int   sysClkArg               = 0    ;    /* clock int routine arg      */
  230. LOCAL BOOL  sysClkConnected         = FALSE;    /* sys clock connect flag     */
  231. LOCAL BOOL  sysClkRunning           = FALSE;    /* sys clock enabled flag     */
  232. LOCAL int   sysClkProcessorTicks           ;    /* Rc32364 clock ticks        */
  233. LOCAL FUNCPTR   sysClkRoutine       = NULL ;    /* clock interrupt routine    */
  235. #ifdef  INCLUDE_TIMESTAMP
  236. LOCAL BOOL  sysTimestampRunning     = FALSE;    /* timestamp running flag     */
  237. #endif  /* INCLUDE_TIMESTAMP */ 
  238.  
  239. /*forward declarations */
  241. void           sysDmaIntrVectorSet (int, void (*fptr) (), void *);
  242. void           sysDmaIntrVectorClr (int);
  243. LOCAL   void   sysDmaIntVecTblInit (void);
  244. LOCAL   void   sysDmaIsr (int parm);
  245. LOCAL   void   sysAuxClkInt ();
  246. LOCAL   void   sysDeviceInterruptDisable (void);
  247.  
  249. /* includes (source file) */
  251. #include "sysDelay.c"           /* uSec delay routine */
  252. #include "sysI2CDrv.c"          /* I2C driver */
  253. #include "sysSerial.c"          /* serial driver */
  254. #include "sysMipsLib.c"         /* Mips common routines */
  255. #include "sysIo.c"              /* I/O routines: must be before PCI includes */
  257. #ifdef  INCLUDE_PCI             /* PCI modules */
  258. #define PCI_AUTO_STATIC_LIST 
  259. #include "pci/pciConfigLib.c"
  260. #include "pci/pciIntLib.c"
  261. #include "pci/pciAutoConfigLib.c"
  262. #include "sysPci.c"
  263. #endif  /* INCLUDE_PCI */
  265.  
  268. /*****************************************************************************
  269. *
  270. * sysModel - return the model name of the CPU board
  271. *
  272. * This routine returns the model name of the CPU board.
  273. *
  274. * RETURNS: A pointer to the string "IDT 79PMC438".
  275. */
  277. char *sysModel (void)
  278.     {
  279.     return ("IDT 79PMC438");
  280.     }
  282. /*******************************************************************************
  283. *
  284. * sysCPUSubsystemName - return the text name of the CPU board / system.
  285. *
  286. * This routine returns the model name of either the CPU CPCI board
  287. * or of the embedded-CPU system board.
  288. *
  289. * RETURNS: A pointer to a text string.
  290. */
  292. char cpu_subsystem_name[64] = ""; /* Initially NULL, set to proper text */
  294. char *sysCPUSubsystemName (void)
  295. {
  296.   /* Table of known platforms based on the IDTRC32438 CPU */
  297.   struct revid_s {
  298.     UINT8 revid;
  299.     char *id_text;
  300.   } platform_list[] = {
  301.     /* {rev_id_value, "Text description"} */
  302.     {0x00, "Modular IDT79PMC438"},
  303.     {0x0,  NULL}
  304.   };
  306.   if (!cpu_subsystem_name[0]) {
  308.     /* UINT8 revid=sysBoardRev(); ******* FIX THIS!!! *******/
  309.     UINT8 revid=0; /* Use this until fixed */
  311.     struct revid_s *platform = &platform_list[0];
  312.     while (platform->id_text != NULL) {
  313.       if (revid == platform->revid) {
  314. strcpy(cpu_subsystem_name,platform->id_text);
  315. break;
  316.       }
  317.       platform++;
  318.     }
  319.     if (!cpu_subsystem_name[0])
  320.       sprintf(cpu_subsystem_name,"Unknown IDTRC32438 (REVID=0x%02X)%c",revid,'');
  321.   }
  322.   return cpu_subsystem_name;
  323. }
  325. /****************************************************************************
  326. *
  327. * sysBspRev - return the bsp version with the revision eg 1.1/<x>
  328. *
  329. * This function returns a pointer to a bsp version with the revision.
  330. * for eg. 1.1/<x>. BSP_REV is concatanated to BSP_VERSION to form the
  331. * BSP identification string.
  332. *
  333. * RETURNS: A pointer to the BSP version/revision string.
  334. */
  336. char * sysBspRev (void)
  337.     {
  338.     return (BSP_VERSION BSP_REV);
  339.     }
  341.  
  342. /*****************************************************************************
  343. *
  344. * sysHwInit - initialize the CPU board hardware
  345. *
  346. * This routine initializes various features of the IDT pmc438.
  347. * It is called from usrInit() in usrConfig.c before interrupts
  348. * are enabled.
  349. * This routine initializes and turns off the timers.
  350. *
  351. * NOTE:
  352. * This routine should not be called directly by the user.
  353. * 
  354. * RETURNS: N/A
  355. */
  357. void sysHwInit (void)
  358.     {
  359.     int sr; /*status register */
  361.  
  362.     /* set default task status register for RC32438 */
  363.    
  364.     sr = RC32438_SR;
  365.     taskSRInit (sr);
  367.     /* init status register but leave interrupts disabled */
  368.     
  369.     intSRSet (sr & ~SR_IE);
  370.    
  371.     /* Initialize the I2C Interface */
  372.     
  373.     sysI2CInit (); 
  374.    
  375.     sysDeviceInterruptDisable ();   /* Disable device interrupts  */
  376.    
  377.     sysPciTlbInit();
  379. #ifdef INCLUDE_PCI
  380.     
  381.     sysPciHostBridgeInit ();       /* Configure the RC32438 PCI host bridge */
  382.           
  383.     /* Initialize PCI modules and perform automatic configuration
  384.      * of PCI memory space.
  385.      */
  386.     
  387.     pciConfigLibInit (PCI_MECHANISM_1, PMC438_PCI_CONFIG_ADDR,
  388.                       PMC438_PCI_CONFIG_DATA, NONE);
  389.                    
  390.     pciIntLibInit ();
  391.      
  392.    
  393.      
  394.     sysPciAutoConfig (); 
  395.     
  396.     pciConfigOutLong(0, 0, 0, PCI_CFG_BASE_ADDRESS_0, PCI_TO_CPU_MEM_BASE);
  398.     /* Always probe for bus1: DC-21150/HB4 PCI-PCI bridge */
  399. #ifdef HB_RESET_HACK
  400.     pciConfigOutByte(0,0x14,0,0x41,1); /* Reset the bridge */
  401. #endif
  402.     sysPCIBridgeProbe(0, 0, 1, 1);  
  403.     
  404. #endif /* INCLUDE_PCI */
  405.  
  406.    
  407.     /* Setup the serial device descriptors. */
  408.     
  409.     sysSerialHwInit ();
  411.     sysWbFlush ();                  /* Flush write buffers */
  412.     
  413.     
  414.      
  415.    
  417.     }
  419. /*****************************************************************************
  420. *
  421. * sysHwInit2 - additional system configuration and initialization
  422. *
  423. * This routine connects system interrupts and does any additional
  424. * configuration necessary.
  425. *
  426. * RETURNS: N/A
  427. *
  428. * NOMANUAL
  429. */
  430.   
  432. void sysHwInit2 (void)
  433.     {
  434.     
  435.     int parm = 0; /*temp variable */
  437.     /* connect sys clock and aux clock interrupts */
  438.    
  439.     (void) intConnect (INUM_TO_IVEC(TMR0_INT_NUM), sysClkInt, 0);  
  440.    
  441.     
  442.     /* Initialize DMA interrupts & connect sysDmaIsr */
  443.     
  444.     sysDmaIntVecTblInit ();
  445.    
  446.     intConnect (INUM_TO_IVEC(INT_VEC_GRP3), sysDmaIsr, (int)parm);
  448.     /* connect serial channel interrupts */
  449.  
  450.     sysSerialHwInit2 ();
  452.     
  453.  
  454.     sysWbFlush ();   /* Flush write buffers */
  455.     
  456.     /* Mask the timer and PCI interrupts */
  457.     
  458.     INTERRUPT.i2.imask &= ~INTR_MASK_TIMER0; 
  459.     GPIO.gpioilevel = 0x0;
  460.     GPIO.gpioistat  = 0x0; 
  461. #if 0 
  462.     *(volatile unsigned char *)(0xb060000b)&=((INTR_PCI_ABCD_MASK>>24)&0xFF);
  463.     *(volatile unsigned char *)(0xb0c00023)&=((INTR_PCI_ABCD_MASK>>24)&0xFF);
  464.     *(volatile unsigned char *)(0xb0c00027)&=((INTR_PCI_ABCD_MASK>>24)&0xFF);
  465. #endif
  466.     INTERRUPT.i6.imask &= ~INTR_PCI_ABCD_MASK;
  467.     }
  468.  
  469. /**************************************************************************
  470. *
  471. * sysRc32438IntDemux - Demultiplex the RC32438 interrupt
  472. *
  473. * The RC32438 ORs most of it's internal device interrupts into
  474. * a single interrupt request - INT3.
  475. *
  476. * This routine determines which internal RC32438 device is causing
  477. * the interrupt and returns the appropriate interrupt number so that
  478. * the ISR can be dispatched. It is used in the intPrioTable (above).
  479. *
  480. * NOTE: This routine runs in the interrupt context!
  481. *
  482. * RETURNS: Interrupt number for connected ISR
  483. */
  484. LOCAL ULONG sysRc32438IntDemux
  485.     (
  486.     int arg                     /* Argument from intPrioTable */
  487.     )
  488.     {
  489.     volatile UINT32 intrStatusVal;  /* Value of master interrupt pend reg */
  490.  
  491.  
  492.     intrStatusVal = INTERRUPT.i5.ipend; 
  493.  
  494.     if (intrStatusVal & UART1_GENERAL_INTR_MASK)
  495.         {
  496.         return COM2_INT_NUM;
  497.         }
  498.     else if (intrStatusVal & UART0_GENERAL_INTR_MASK)
  499.         {
  500.         return COM1_INT_NUM;
  501.         }
  502.     else if (intrStatusVal & INTR_MASK_ETH0_OVR ) 
  503.         {
  504.         return ETH_OVR_NUM0;
  505.         }
  506.     else if (intrStatusVal & INTR_MASK_ETH1_OVR ) 
  507.         {
  508.         return ETH_OVR_NUM1;
  509.         }
  510.     else
  511.         {
  512.         return HIGH_VEC;
  513.         }
  514.     }
  517. /**************************************************************************
  518. *
  519. * sysRc32438GpioDemux - Demultiplex the RC32438 GPIO interrupts
  520. *
  521. *  
  522. *
  523. * This routine determines which GPIO pin of RC32438  is causing
  524. * the interrupt and returns the appropriate interrupt number so that
  525. * the ISR can be dispatched. It is used in the intPrioTable (above).
  526. *
  527. * NOTE: This routine runs in the interrupt context!
  528. *
  529. * RETURNS: Interrupt number for connected ISR
  530. */
  531. LOCAL ULONG sysRc32438GpioDemux
  532.     (
  533.     int arg    /* Argument from intPrioTable */
  534.     )
  535.     {
  536.     volatile UINT32 intrStatusVal;   /* Value of master interrupt pend reg */
  537.      
  538.     intrStatusVal = INTERRUPT.i6.ipend;  
  539.     GPIO.gpioistat  = 0;
  540.     if (intrStatusVal & INTR_PCI_ABCD_MASK)
  541.         {
  542.         return INT_NUM_PCI_ABCD; 
  543.         }
  544.     else
  545.         {
  546.         return HIGH_VEC;
  547.         }
  548.     }    
  549. /***************************************************************************
  550. *
  551. * sysDeviceInterruptDisable - Disable device interrupts
  552. *
  553. * This routine disables devices interrupts. It is done as a safeguard
  554. * during cold boots, but is required on a warm boot.
  555. *
  556. * RETURNS: N/A
  557. *
  558. */
  560. LOCAL void sysDeviceInterruptDisable (void)
  561.     {
  562.   
  563.     volatile UINT32* auxTimerIMsk  = (UINT32*)(AUX_TIMER_INTR_MASK);
  564.  
  565.     /* Clear Ethernet Interface  */
  567.     sysOutLong(ETH_INTFC0,0);
  568.     sysOutLong(ETH_INTFC1,0);
  569.     
  570.     /* Clear DMA Controller Registers for ETH0 */
  571.    
  572.     sysOutLong (DMA2C,0);
  573.     sysOutLong (DMA3C,0);
  574.     sysOutLong (DMA2S,0);
  575.     sysOutLong (DMA3S,0);
  576.     sysOutLong (DMA2DPTR,0);
  577.     sysOutLong (DMA3DPTR,0);
  578.     sysOutLong (DMA2NDPTR,0);
  579.     sysOutLong (DMA3NDPTR,0);
  580.     sysOutLong (DMA4C,0);
  581.     sysOutLong (DMA5C,0);
  582.     sysOutLong (DMA4S,0);
  583.     sysOutLong (DMA5S,0);
  584.     sysOutLong (DMA4DPTR,0);
  585.     sysOutLong (DMA5DPTR,0);
  586.     sysOutLong (DMA4NDPTR,0);
  587.     sysOutLong (DMA5NDPTR,0);
  588.     
  589.     
  590.     /* Mask and clear RC32438 UART interrupts */
  591.     
  592.     INTERRUPT.i5.imask |= 0xFC000 ; 
  594.     /*Mask and clear Aux Timer interrupts */
  595.     
  596.     *auxTimerIMsk = (UINT32)0xffffffff; 
  597.     
  598.     /* Mask and clear RC32438 timer interrupts */
  599.     
  600.     TIMER.ct0.ctc = ( TIMER.ct0.ctc & ~0x20 ) ;
  601.     INTERRUPT.i2.imask |= 0x1F ;
  602.     
  603.     INTERRUPT.i6.imask |= 0xffffffff;
  604.     GPIO.gpioilevel = 0x0;
  605.     GPIO.gpioistat  = 0x0; 
  606.     }
  609. /*****************************************************************************
  610. *
  611. * sysPhysMemTop - get the address of the top of memory
  612. *
  613. * This routine returns the address of the first missing byte of memory, which
  614. * indicates the top of memory.
  615. *
  616. * NOTE: Do not adjust LOCAL_MEM_SIZE to reserve memory for application
  617. * use.  See sysMemTop() for more information on reserving memory.
  618. *
  619. * RETURNS: The address of the top of memory.
  620. */
  622. char *sysPhysMemTop (void)
  623.     {
  624.   
  625.     static char * memTop = NULL; /* Returned pointer to top of memory */
  626.  
  627.     if (memTop == NULL)
  628.         {
  629.         memTop = (char *)(LOCAL_MEM_LOCAL_ADRS + LOCAL_MEM_SIZE);
  630.         }
  631.     return (memTop);
  632.     }
  634. /*****************************************************************************
  635. *
  636. * sysMemTop - get the address of the top of logical memory
  637. *
  638. * This routine returns the address of the first unusable byte of memory.
  639. * VxWorks will not use any memory at or above this address.
  640. *
  641. * The user can reserve local memory from the board by declaring the
  642. * macro USER_RESERVED_MEM with the amount of memory to reserve. This
  643. * routine will return a pointer to the first byte of the reserved memory
  644. * area.
  645. *
  646. * RETURNS: The address of the top of usable memory.
  647. */
  649. char *sysMemTop (void)
  650.     {
  651.     static char * memTop = NULL; /* Returned pointer to top of memory */
  652.   
  653.     if (memTop == NULL)
  654.         {
  655.         memTop = sysPhysMemTop () - USER_RESERVED_MEM;
  656.         }
  658.     return (memTop);
  659.     }
  661. #ifndef BROADCOM_BSP
  662. /*****************************************************************************
  663. *
  664. * sysToMonitor - transfer control to the ROM monitor
  665. *
  666. * This routine transfers control to the ROM monitor.  Normally, it is called
  667. * only by reboot()--which services ^X--and bus errors at interrupt level.
  668. * However, in some circumstances, the user may wish to introduce a
  669. * <startType> to enable special boot ROM facilities.
  670. *
  671. * RETURNS: Does not return.
  672. */
  674. STATUS sysToMonitor
  675.     (
  676.     int startType    /* parameter passed to ROM to tell it how to boot */
  677.     )
  678.     {
  679.   
  680.     FUNCPTR pRom = (FUNCPTR) (ROM_TEXT_ADRS + 8);
  682.     sysWbFlush ();   /* Flush write buffers */
  684.     (*pRom) (startType);
  686.     return (OK);    /* in case we ever continue from rom monitor */
  687.     }
  688. #endif /*BROADCOM_BSP */
  690. /*****************************************************************************
  691. *
  692. * sysAutoAck - acknowledge the RC32438 interrupt condition 
  693. *
  694. * This routine acknowledges an RC32438 interrupt for a specified interrupt
  695. * vector.
  696. *
  697. * NOTE:
  698. * This routine must be provided on all RC32438 board support packages.
  699. * Most interrupts are automatically acknowledged in the interrupt service
  700. * routine.
  701. *
  702. * RETURNS: The result of the interrupt acknowledge cycle.
  703. */
  705. int sysAutoAck
  706.     (
  707.     int vecNum              /* vector num of interrupt that bugs us */
  708.     )
  709.     {
  710.     int result = OK;        /* Returned status */
  711.   
  712.     switch (vecNum)
  713.         {
  714.         case IV_TIMER_VEC:
  715.             sysCompareSet (0);
  716.             break;
  717.         case IV_SWTRAP0_VEC:        /* software trap 0 */
  718.             result = sysSw0Ack ();
  719.             break;
  720.         case IV_SWTRAP1_VEC:        /* software trap 1 */
  721.             result = sysSw1Ack ();
  722.             break;
  723.         default:
  724.             result = ERROR;
  725.             break;
  726.         }
  727.     sysWbFlush ();                  /* Flush write buffers */
  728.     return (result);
  729.     }
  730. /*****************************************************************************
  731. *
  732. * sysClkEnable - turn on system clock interrupts
  733. *
  734. * This routine enables system clock interrupts.
  735. *
  736. * RETURNS: N/A
  737. *
  738. * SEE ALSO: sysClkDisable(), sysClkRateSet()
  739. */
  741. void sysClkEnable (void)
  742.     {
  743.     /* start the timer */
  744.     int key;
  745.     volatile UINT32* tmr0ctrl      = (UINT32*)(CNTR_TMR0_CTRLREG);
  746.      
  747.     sysClkProcessorTicks = CPU_CLOCK_RATE /sysClkTicksPerSecond ;
  748.     key = intLock ();
  749.     sysCompareSet (0);
  750.     sysCountSet (1);
  751.     sysCompareSet (sysClkProcessorTicks);
  752.     
  753.     sysSoftCompare = sysClkProcessorTicks;
  754.     sysClkRunning = TRUE;  
  755.     *tmr0ctrl = (UINT32)TIMER_ENABLE ;
  756.     intUnlock (key);
  757.     }
  759. /*****************************************************************************
  760. *
  761. * sysClkRateGet - get the system clock rate
  762. *
  763. * This routine returns the interrupt rate of the system clock.
  764. *
  765. * RETURNS: The number of ticks per second of the system clock.
  766. *
  767. * SEE ALSO: sysClkRateSet()
  768. */
  770. int sysClkRateGet (void)
  771.     {
  772.     return (sysClkTicksPerSecond);
  773.     }
  775. /*****************************************************************************
  776. *
  777. * sysClkRateSet - set the system clock rate
  778. *
  779. * This routine sets the interrupt rate of the system clock.  It does not
  780. * enable system clock interrupts.  Normally, it is called by usrRoot() in
  781. * usrConfig.c.
  782. *
  783. * NOTE
  784. * The RC32364 internal timer is used to provide the system clock.
  785. *
  786. * RETURNS: OK, or ERROR if the tick rate is invalid or the timer cannot be
  787. * set.
  788. *
  789. * SEE ALSO: sysClkDisable(), sysClkEnable(), sysClkRateGet()
  790. */
  792. STATUS sysClkRateSet
  793.     (
  794.     int ticksPerSecond  /* number of clock interrupts per second */
  795.     )
  796.     {
  797.     if (ticksPerSecond < SYS_CLK_RATE_MIN || ticksPerSecond > SYS_CLK_RATE_MAX)
  798.         return (ERROR);
  800.     sysClkTicksPerSecond = ticksPerSecond;
  802.     if (sysClkRunning)
  803.         {
  804.         sysClkDisable ();
  805.         sysClkEnable ();
  806.         }
  808.     return (OK);
  809.     }
  811. /*****************************************************************************
  812. *
  813. * sysClkInt - handle a system clock interrupt
  814. *
  815. * This routine handles a system clock interrupt.  It increments the value 
  816. * on the front panel display and calls the routine installed by
  817. * sysClkConnect().
  818. *
  819. * RETURNS: N/A
  820. */
  822. LOCAL void sysClkInt (void)
  823.     {
  824.     
  825.     volatile unsigned int *ptr;
  826.     ptr = (unsigned int *) CNTR_TMR0_CTRLREG;
  827.     TIMER.ct0.ctc = 0;
  829.  
  830.     sysCountSet(0);
  831.    
  832.     sysCompareSet(CPU_CLOCK_RATE /sysClkTicksPerSecond);
  833.   
  834.     *ptr = 0x1;
  835.     
  836. #if defined(PCI_INTA_HACK)
  837.      SOC_INTR_INVOKE();
  838. #endif
  839.      if (sysClkRoutine != NULL)
  840.         (*sysClkRoutine) (sysClkArg);
  841.  
  842.     }
  845. /*****************************************************************************
  846. *
  847. * sysClkConnect - connect a routine to the system clock interrupt
  848. *
  849. * This routine specifies the interrupt handler to be called at each system
  850. * clock interrupt.  It does not enable system clock interrupts.  Normally,
  851. * it is called from usrRoot() in usrConfig.c to connect usrClock() to the
  852. * system clock interrupt.  Other standard interrupt handlers are also set up
  853. * at this time.
  854. *
  855. * RETURN: OK, or ERROR if the routine cannot be connected to the interrupt.
  856. *
  857. * SEE ALSO: intConnect(), usrClock()
  858. */
  860. STATUS sysClkConnect
  861.     (
  862.     FUNCPTR routine,    /* routine called at each system clock interrupt */
  863.     int arg             /* argument with which to call routine           */
  864.     )
  865.     {
  866.     if (sysClkConnected == FALSE)
  867.         {
  868.         sysHwInit2 ();
  869.         sysClkConnected = TRUE;
  870.         }
  872.     sysClkRoutine   = routine;
  873.     sysClkArg       = arg;
  875.     return (OK);
  876.     }
  878. /*****************************************************************************
  879. *
  880. * sysClkDisable - turn off system clock interrupts
  881. *
  882. * This routine disables system clock interrupts.
  883. *
  884. * RETURNS: N/A
  885. *
  886. * SEE ALSO: sysClkEnable(), sysClkRateSet()
  887. */
  889. void sysClkDisable (void)
  890.     {
  891.     int key;
  892.     volatile UINT32* tmr0ctrl      = (UINT32*)(CNTR_TMR0_CTRLREG);
  893.   
  894.     /* we cannot disable interrupts so we do this instead... */
  896.     key = intLock ();
  897.     sysCompareSet (0);
  898.     sysCountSet (1);
  899.     sysClkProcessorTicks = CPU_CLOCK_RATE /sysClkTicksPerSecond;
  900.     sysCompareSet (sysClkProcessorTicks);
  901.     sysSoftCompare = sysClkProcessorTicks;
  902.     sysClkRunning = FALSE;
  903.     *tmr0ctrl = (UINT32)TIMER_DISABLE; 
  904.     intUnlock (key);
  905.     }
  908. /*****************************************************************************
  909. *
  910. * sysAuxClkInt - interrupt level processing for auxiliary clock
  911. *
  912. * This routine handles the auxiliary clock interrupt.  It is attached to the
  913. * clock interrupt vector by the routine sysAuxClkConnect().
  914. * The appropriate routine is called and the interrupt is acknowleged.
  915. *
  916. * RETURNS: N/A
  917. */
  919. LOCAL void sysAuxClkInt (void)
  920.     {
  921.      
  922.     if (sysAuxClkRoutine != NULL)
  923.         (*sysAuxClkRoutine) (sysAuxClkArg); /*call system clock routine */ 
  925.  
  926.     /* Mask and clear RC32438 timer interrupts */
  927.     
  928.     TIMER.ct1.ctc = ( TIMER.ct1.ctc & ~0x20 ) ;
  929.  
  930.     sysWbFlush ();                          /* Flush write buffers */   
  931.     
  932.     }
  934. /*****************************************************************************
  935. *
  936. * sysAuxClkConnect - connect a routine to the auxiliary clock interrupt
  937. *
  938. * This routine specifies the interrupt service routine to be called at each
  939. * auxiliary clock interrupt.  It does not enable auxiliary clock
  940. * interrupts.
  941. *
  942. * RETURNS: OK, or ERROR if the routine cannot be connected to the interrupt.
  943. *
  944. * SEE ALSO: intConnect(), sysAuxClkEnable()
  945. */
  947. STATUS sysAuxClkConnect
  948.     (
  949.     FUNCPTR routine,    /*routine called at each aux clock interrupt   */    
  950.     int     arg         /*argument to auxiliary clock interrupt routine*/ 
  951.     )
  952.     {
  953.     if (!sysAuxClkConnected)
  954.         {
  955.         sysAuxClkConnected = TRUE;
  956.         }
  958.     sysAuxClkRoutine = routine;
  959.     sysAuxClkArg = arg;
  961.     return (OK);
  962.     }
  964. /*****************************************************************************
  965. *
  966. * sysAuxClkDisable - turn off auxiliary clock interrupts
  967. *
  968. * This routine disables auxiliary clock interrupts.
  969. *
  970. * RETURNS: N/A
  971. *
  972. * SEE ALSO: sysAuxClkEnable()
  973. */
  975. void sysAuxClkDisable (void)
  976.     {
  977.     sysRc32438ClkDisable ();
  978.     sysAuxClkRunning = FALSE ;
  979.     }
  981. /*****************************************************************************
  982. *
  983. * sysAuxClkEnable - turn on auxiliary clock interrupts
  984. *
  985. * This routine enables auxiliary clock interrupts.
  986. *
  987. * RETURNS: N/A
  988. *
  989. * SEE ALSO: sysAuxClkConnect(), sysAuxClkDisable(), sysAuxClkRateSet()
  990. */
  992. void sysAuxClkEnable (void)
  993.     {
  994.     sysTimer1Routine = (FUNCPTR) sysAuxClkInt;
  995.     sysRc32438ClkEnable (sysAuxClkTicksPerSecond);
  996.     sysAuxClkRunning = TRUE ;
  997.     }
  999. /****************************************************************************
  1000. *
  1001. * sysAuxClkRateGet - get the auxiliary clock rate
  1002. *
  1003. * This routine returns the interrupt rate of the auxiliary clock.
  1004. *
  1005. * RETURNS: The number of ticks per second of the auxiliary clock.
  1006. *
  1007. * SEE ALSO: sysAuxClkEnable(), sysAuxClkRateSet()
  1008. */
  1010. int sysAuxClkRateGet (void)
  1011.     {
  1012.     return (sysAuxClkTicksPerSecond);
  1013.     }
  1015. /*******************************************************************************
  1016. *
  1017. * sysAuxClkRateSet - set the auxiliary clock rate
  1018. *
  1019. * This routine sets the interrupt rate of the auxiliary clock.
  1020. * It does not enable auxiliary clock interrupts.
  1021. *
  1022. * RETURNS: OK, or ERROR if the tick rate is invalid or the timer cannot be set.
  1023. *
  1024. * SEE ALSO: sysAuxClkEnable(), sysAuxClkRateGet()
  1025. */
  1027. STATUS sysAuxClkRateSet
  1028.     (
  1029.     int ticksPerSecond     /* number of clock interrupts per second*/ 
  1030.     )
  1031.     {
  1032.     if ( ticksPerSecond < AUX_CLK_RATE_MIN || ticksPerSecond > AUX_CLK_RATE_MAX)
  1033.         {
  1034.         return (ERROR);
  1035.         }
  1036.     sysAuxClkTicksPerSecond = ticksPerSecond ;
  1037.      
  1038.     if ( sysAuxClkRunning )
  1039.         {
  1040.         sysAuxClkDisable ();
  1041.         sysAuxClkEnable ();
  1042.         }
  1043.         
  1044.     return (OK);
  1045.     }
  1047. /***************************************************************************
  1048. *
  1049. * sysCacheInit - initialize the RC32438 cache library
  1050. *
  1051. * Initializes the generic cache library to work with the IDTPMC438.
  1052. *
  1053. * RETURNS: OK or ERROR
  1054. *
  1055. * NOMANUAL
  1056. */
  1057.  
  1058. LOCAL STATUS sysCacheInit
  1059.     (
  1060.     CACHE_MODE instMode,
  1061.     CACHE_MODE dataMode
  1062.     )
  1063.     {
  1064. #if defined (AUTO_CACHE_DETECT)
  1066.     UINT32 config1 = sysConfig1Get();
  1067.     int iCacheSize;
  1068.     int iCacheLineSize;
  1069.     int iCacheAssoc;
  1070.     int dCacheSize;
  1071.     int dCacheLineSize;
  1072.     int dCacheAssoc;
  1073.     
  1074.     iCacheSize =
  1075.     cacheSize[((config1 & IDT32438_CONFIG1_IS_MSK) >> IDT32438_CONFIG1_IS_SHF)];
  1076.    
  1077.     iCacheLineSize =
  1078.     cacheLineSize[((config1 & IDT32438_CONFIG1_IL_MSK) 
  1079.                  >> IDT32438_CONFIG1_IL_SHF)];
  1080.    
  1081.     iCacheAssoc =
  1082.     cacheAssoc[((config1 & IDT32438_CONFIG1_IA_MSK) 
  1083.               >> IDT32438_CONFIG1_IA_SHF)];
  1084.    
  1085.     iCacheSize *= (iCacheLineSize * iCacheAssoc);
  1087.     dCacheSize =
  1088.     cacheSize[((config1 & IDT32438_CONFIG1_DS_MSK) 
  1089.              >> IDT32438_CONFIG1_DS_SHF)];
  1090.    
  1091.     dCacheLineSize =
  1092.     cacheLineSize[((config1 & IDT32438_CONFIG1_DL_MSK)
  1093.                  >> IDT32438_CONFIG1_DL_SHF)];
  1094.    
  1095.     dCacheAssoc =
  1096.     cacheAssoc[((config1 & IDT32438_CONFIG1_DA_MSK) 
  1097.               >> IDT32438_CONFIG1_DA_SHF)];
  1098.    
  1099.     dCacheSize *= (dCacheLineSize * dCacheAssoc);
  1101.     return cache4kcLibInit(
  1102.         instMode,       /* I-cache mode */
  1103.         dataMode,       /* D-cache mode */
  1104.         iCacheSize,
  1105.         iCacheLineSize,
  1106.         dCacheSize,
  1107.         dCacheLineSize
  1108.         );
  1109. #else
  1110.     return cache4kcLibInit(
  1111.         instMode,       /* I-cache mode */
  1112.         dataMode,       /* D-cache mode */
  1113.         iCacheSize,
  1114.         iCacheLineSize,
  1115.         dCacheSize,
  1116.         dCacheLineSize
  1117.         );
  1118. #endif
  1119.     }
  1121.     
  1122. /******************************************************************************
  1123. *
  1124. * sysNvRamGet - get the contents of non-volatile RAM
  1125. *
  1126. * This routine copies the contents of non-volatile memory into a specified
  1127. * string.  The string will be terminated with an EOS.
  1128. *
  1129. * RETURNS: OK, or ERROR if access is outside the non-volatile RAM range.
  1130. *
  1131. * SEE ALSO: sysNvRamSet()
  1132. */
  1134. STATUS sysNvRamGet
  1135.     (
  1136.     char *string,    /* where to copy non-volatile RAM           */
  1137.     int  strLen,     /* maximum number of bytes to copy          */
  1138.     int  offset      /* byte offset into non-volatile RAM        */
  1139.     )
  1140.     {
  1141.     int key;                    /* Saved status register for int lock */
  1143.     offset += NV_BOOT_OFFSET;   /* boot line begins at <offset> = 0 */
  1145.     if ((offset < 0) || (strLen < 0) || ((offset + strLen) > NV_RAM_SIZE))
  1146.         return (ERROR);
  1147.     /* Exclude preemption */
  1149.     key = intLock ();
  1151.     sysI2CStringRead (I2C_READ_WRITE_ADRS + offset, string, strLen);
  1152.     string [strLen] = EOS;
  1154.     intUnlock (key);
  1156.     return (OK);
  1157.     }
  1159. /*******************************************************************************
  1160. *
  1161. *
  1162. * sysNvRamSet - write to non-volatile RAM
  1163. *
  1164. * This routine copies a specified string into non-volatile RAM.
  1165. *
  1166. * RETURNS: OK, or ERROR if access is outside the non-volatile RAM range.
  1167. *
  1168. * SEE ALSO: sysNvRamGet()
  1169. */
  1171. STATUS sysNvRamSet
  1172.     (
  1173.     char * string,       /* string to be copied into non-volatile RAM */
  1174.     int    strLen,       /* maximum number of bytes to copy           */
  1175.     int    offset        /* byte offset into non-volatile RAM         */
  1176.     )
  1177.     {
  1178.     int key;                    /* Saved status register for int lock */
  1180.     offset += NV_BOOT_OFFSET;   /* Boot line begins at <offset> = 0 */
  1182.     if ((offset < 0) || (strLen < 0) || ((offset + strLen) > NV_RAM_SIZE))
  1183.         return (ERROR);
  1185.     /* Exclude preemption */
  1187.     key = intLock ();
  1189.     sysI2CStringWrite ((I2C_READ_WRITE_ADRS + offset), string, strLen);
  1191.     /* Allow preemption */
  1193.     intUnlock (key);
  1195.     return (OK);
  1197.     }
  1199.  
  1201. /******************************************************************
  1202. * sysDmaIntVecTblInit - Initialize the DMA interrupt vector table.
  1203. * 
  1204. * Initialize the DMA interrupt vector table.
  1205. *
  1206. * RETURNS N/A
  1207. */
  1208. LOCAL void sysDmaIntVecTblInit ()
  1209.     {
  1210.     int     vect; /* interrupt vector */
  1212.     for (vect = 0; vect < MAX_DMA_INTRS; vect++)
  1213.         {
  1214.         dmaInterruptVectors[vect].func = (void *)0;
  1215.         dmaInterruptVectors[vect].param = (void *)0;
  1216.         }
  1217.     }
  1219. /*****************************************************************************
  1220. *
  1221. * sysDmaIntEnable - enable interrupts for a DMA channel
  1222. * 
  1223. * This function enables DMA interrupts at the RC32438 interrupt
  1224. * controller for a single DMA channel. It does not alter the system
  1225. * status register mask or any DMA device registers.
  1226. *
  1227. * RETURNS: N/A
  1228. */
  1230. void sysDmaIntEnable
  1231.     (
  1232.     unsigned int   dmaChan  /* DMA channel number (0-15) */
  1233.     )
  1234.     {
  1236.     if (dmaChan < MAX_DMA_INTRS)
  1237.         INTERRUPT.i3.imask &= ~(1 << dmaChan);
  1239.     return;
  1240.     
  1241.     }
  1243. /******************************************************************
  1244. *
  1245. * sysDmaIntDisable - disable interrupts for a DMA channel
  1246. * 
  1247. * This function disables DMA interrupts at the RC32438 interrupt
  1248. * controller for a single DMA channel. It does not alter the system
  1249. * status register mask or any DMA device registers.
  1250. *
  1251. * RETURNS: N/A
  1252. */
  1254. void sysDmaIntDisable
  1255.     (
  1256.     unsigned int    dmaChan  /* DMA channel number (0-15) */
  1257.     )
  1258.     {
  1260.     if (dmaChan < MAX_DMA_INTRS)
  1261.         INTERRUPT.i3.imask |= (1 << dmaChan);
  1263.     return;
  1264.     
  1265.     }
  1267. /******************************************************************
  1268. * sysDmaIntrVectorClr - Clear a DMA interrupt vector
  1269. * 
  1270. * Clear the DMA interrupt vector table entry for this vector.
  1271. *
  1272. * RETURNS: N/A
  1273. */
  1275. void sysDmaIntrVectorClr
  1276.     (
  1277.     int         vect        /* interrupt vector */
  1278.     )
  1279.     {
  1280.     if (vect < 0 || vect >= MAX_DMA_INTRS)
  1281.         return;
  1282.     dmaInterruptVectors[vect].func = (void *) NULL;
  1283.     dmaInterruptVectors[vect].param = NULL;
  1284.     }
  1286. /******************************************************************
  1287. * sysDmaIntrVectorSet - Set a DMA interrupt vector
  1288. * 
  1289. * Set the DMA interrupt vector table entry to the handler routine.
  1290. *
  1291. * RETURNS: N/A
  1292. */
  1294. void sysDmaIntrVectorSet
  1295.     (
  1296.     int         vect,       /* interrupt vector */
  1297.     void (*fptr) (),        /* function pointer */
  1298.     void *      param       /* parameter to be passed to the function */
  1299.     )
  1300.     {
  1301.     if (vect < 0 || vect >= MAX_DMA_INTRS)
  1302.         return;
  1303.     dmaInterruptVectors[vect].func = (void *) fptr;
  1304.     dmaInterruptVectors[vect].param = param;
  1305.     }
  1307. /******************************************************************
  1308. * sysDmaIsr - DMA interrupt service routine
  1309. * 
  1310. * RC32438 has 12 DMA channels that share same interrupt line.  The DMA
  1311. * interrupt service routine demultiplexes this interrupt for the all
  1312. * the dma channels. The device driver using a dma channel, initializes
  1313. * a global list ( having maximum of 12 entries : dma channel 0 through
  1314. * 11) which is referenced by the dmaIsr function to call the
  1315. * appropriate interrupt handlers.
  1316. *
  1317. * RETURNS: N/A
  1318. */
  1320. LOCAL void sysDmaIsr
  1321.     (
  1322.     int parm                       /* parameter value */
  1323.     )
  1324.     {
  1325.     int         vect;       /* index into DMA interrupt vector array */
  1326.     UINT32      iPend;      /* interrupt pending register value */ 
  1327.     UINT32      mask;       /* bit mask */
  1328.     unsigned    (*func) ();
  1330.     /* Read the IPEND3 register */
  1331.    
  1332.     iPend = INTERRUPT.i3.ipend;
  1334.     mask = 1;
  1335.     for (vect = 0; (iPend != 0) && (vect < MAX_DMA_INTRS); vect++)
  1336.         {
  1337.         if (iPend & mask)
  1338.             {
  1339.             func = ((unsigned (*) ()) dmaInterruptVectors[vect].func);
  1340.             if (func != NULL)
  1341.                 {
  1342.                 (* func) (vect, dmaInterruptVectors[vect].param);
  1343.                 }
  1344.                 else
  1345.                 {
  1346.                 (void)logMsg("Uninit DMA int: %dn", vect, 2, 3, 4, 5, 6);
  1347.                 INTERRUPT.i3.imask |= mask;
  1348.                 }
  1349.             iPend &= ~mask;
  1350.             }
  1351.         mask = mask << 1;
  1352.         }
  1353.     }
  1354. /****************************************************************************
  1355. * FUNCTION : sysTimerIsr
  1356. *
  1357. * 
  1358. * 
  1359. * RC32438 has 5 timers that share same interrupt line.
  1360. * The timer interrupt service routine demultiplexes this interrupt for
  1361. * all the  timers. The timerIsr function calls the
  1362. * appropriate interrupt handlers. In order to maintain equal opportunity
  1363. * for all the timers, the timerIsr function services  all the timer 
  1364. * interrupts in an order to ensure fairness to the timer interrupts among
  1365. * the active timers.
  1366. *
  1367. * 
  1368. * RETURNS: N/A
  1369. */
  1370. LOCAL ULONG sysTimerIsr
  1371.     (
  1372.     int parm                   /* parameter value */
  1373.     )
  1374.     {
  1375.     UINT32  ipend;             /*interrupt pending reg */
  1376.     UINT32  imask;             /*mask value */ 
  1377.  
  1378.  
  1379.      
  1380.     ipend = INTERRUPT.i2.ipend;
  1381.     imask = INTERRUPT.i2.imask;
  1382.     ipend &= ~imask;
  1384.     if (ipend & CNTR_TMR0_MASK)
  1385.         {
  1386.         return TMR0_INT_NUM;
  1387.         }
  1388.     if (ipend & CNTR_TMR1_MASK)
  1389.         {
  1390.         if (sysTimer1Routine != NULL)
  1391.             (*sysTimer1Routine) ();      
  1393.     TIMER.ct1.ctc &= ~CTC_TO;
  1394.         }
  1395.     if (ipend & CNTR_TMR2_MASK)
  1396.         {
  1397.         if (sysTimer2Routine != NULL)
  1398.             (*sysTimer2Routine) ();     
  1400.         TIMER.ct2.ctc = CTC_EN;
  1401.         }
  1402.     if (ipend & REFRESH_TIMER_MASK)
  1403.         {
  1404.         if (sysRefreshTimerRoutine != NULL)
  1405.             (*sysRefreshTimerRoutine) ();   
  1407.         TIMER.rtc = CTC_EN;
  1408.         }
  1409.     if (ipend & WDOG_TMR_TO_MASK)
  1410.         {
  1411.         if (sysWatchdogTimerRoutine != NULL)
  1412.             (*sysWatchdogTimerRoutine) ();  
  1414.         SYSINTEG.wtc &= ~WTC_TO;
  1415.         SYSINTEG.errcs &= ~ERRCS_WTO;
  1416.         }
  1417.     if (ipend & UNDEC_CPU_WR_MASK)
  1418.         {
  1419.         if (sysUndecodedCPUWriteRoutine!= NULL)
  1420.             (*sysUndecodedCPUWriteRoutine) ();  
  1422.         SYSINTEG.errcs &= ~ERRCS_UCW;
  1423.         }
  1424.      return (OK);
  1425.     }
  1427. /*******************************************************************************
  1428. *
  1429. * sysRc32438ClkEnable - enable the Rc32438 timer0 interrupt
  1430. *
  1431. * This routine enables the Rc32438 timer0 to give a periodic interrupt.
  1432. * The <ticksPerSecond> parameter specifies the number of interrupts to generate
  1433. * per second. 
  1434. *
  1435. *
  1436. * RETURNS: N/A
  1437. *
  1438. * SEE ALSO: sysRc32438ClkDisable()
  1439. *
  1440. * NOMANUAL
  1441. */
  1442. void sysRc32438ClkEnable
  1443.     (
  1444.     int ticksPerSecond   /*interrupt frequency */
  1445.     )
  1446.     {
  1447.     volatile UINT32* rc32438Timer1CntlReg ; /*timer control reg*/
  1448.     volatile UINT32* rc32438Timer1CntReg  ; /*timer count reg */
  1449.     volatile UINT32* rc32438Timer1CmpReg  ; /*timer compare reg */
  1450.     volatile UINT32* rc32438TimerMask     ; /*timer mask reg */
  1451.     volatile UINT32* rc32438TimerPend     ; /*timer pend reg */
  1452.     int      key                          ; /*temp variable */
  1454.     rc32438Timer1CntlReg = (UINT32*)AUX_TIMER_CNTL_REG  ;
  1455.     rc32438Timer1CntReg  = (UINT32*)AUX_TIMER_CNT_REG   ;
  1456.     rc32438Timer1CmpReg  = (UINT32*)AUX_TIMER_CMP_REG   ;
  1457.     rc32438TimerPend     = (UINT32*)AUX_TIMER_INTR_PEND ;
  1458.     rc32438TimerMask     = (UINT32*)AUX_TIMER_INTR_MASK ;
  1460.     key = intLock ();
  1461.     *rc32438Timer1CntlReg = (UINT32)0x0; /* Clear any pending interrupt */
  1462.     *rc32438Timer1CntReg = (UINT32)0x0;  /* Count is made Zero */
  1463.                                          /* Compare=BUSFREQ/ticks PerSecond */
  1464.     *rc32438Timer1CmpReg  = (UINT32)(AUX_CLOCK_FREQ / ticksPerSecond) ;
  1465.     *rc32438Timer1CntlReg = (UINT32)0x0; /* Clear any pending interrupt */
  1466.     *rc32438TimerMask    &= (UINT32)0xfffffffd;
  1467.                                          /* Enable Timer1 Interrupt */
  1468.     *rc32438Timer1CntlReg = (UINT32)0x1; /* Enable the Timer1       */
  1470.     intUnlock (key);
  1471.     }
  1473. /*****************************************************************************
  1474. *
  1475. * sysRc32438ClkDisable - disable the Rc32438 timer1 interrupt
  1476. *
  1477. * This routine disables the Rc32438 timer1 interrupt.
  1478. *
  1479. * RETURNS: N/A
  1480. *
  1481. * SEE ALSO: sysRc32438ClkEnable()
  1482. *
  1483. * NOMANUAL
  1484. */
  1487. void sysRc32438ClkDisable ()
  1488.     {
  1489.     UINT32* rc32438Timer1CntlReg ; /*timer control reg */
  1490.     UINT32* rc32438Timer1CntReg  ; /*timer count reg */
  1491.     UINT32* rc32438Timer1CmpReg  ; /*timer compare reg */
  1492.     UINT32* rc32438TimerMask     ; /*timer mask reg */
  1493.     UINT32* rc32438TimerPend     ; /*timer pend reg */
  1494.     int     key                  ; /*temp variable */
  1496.     rc32438Timer1CntlReg = (UINT32*)AUX_TIMER_CNTL_REG  ;
  1497.     rc32438Timer1CntReg  = (UINT32*)AUX_TIMER_CNT_REG   ;
  1498.     rc32438Timer1CmpReg  = (UINT32*)AUX_TIMER_CMP_REG   ;
  1499.     rc32438TimerPend     = (UINT32*)AUX_TIMER_INTR_PEND ;
  1500.     rc32438TimerMask     = (UINT32*)AUX_TIMER_INTR_MASK ;
  1503.     key = intLock ();
  1504.     *rc32438Timer1CntlReg = (UINT32)0x0;        /* Disable the Timer1 */
  1505.     *rc32438Timer1CntReg  = (UINT32)0x0;        /* Count is made Zero */
  1506.     *rc32438TimerMask     |= (UINT32)0xfffffffE;/* Disable Timer1 Interrupt */
  1507.     intUnlock (key);
  1508.     }
  1511. /**************************************************************************
  1512. *
  1513. * sysEnetReverse - Reverse bytes in ethernet address array
  1514. *
  1515. * This routine reverses the order of bytes in a 6-character array.
  1516. * This utility is required because the boot shell 'N' command and
  1517. * the ethernet driver expect the opposite byte order for ethernet
  1518. * addresses. Given an address 00:11:22:33:44:55, the boot shell
  1519. * expects to see it stored in an array as 55,44,33,22,11,00, but
  1520. * the ethernet driver expects to see it as 00,11,22,33,44,55.
  1521. *
  1522. * RETURNS: N/A
  1523. */
  1525. LOCAL void sysEnetReverse
  1526.     (
  1527.     uchar_t *inpAddr, /* Input address array */
  1528.     uchar_t *revAddr  /* Reversed output array */
  1529.     )
  1530.     {
  1531.     int idx;                    /* loop index */
  1533.     for (idx = 0; idx < ENET_SIZE; idx++)
  1534.         {
  1535.         revAddr[idx] = inpAddr[ENET_SIZE - idx - 1];
  1536.         }
  1537.     }
  1539. /**************************************************************************
  1540. *
  1541. * sysEnetAddrGet - Read ethernet address from NVRAM for boot shell.
  1542. *
  1543. * This routine reads the ethernet address saved in NVRAM and reverses
  1544. * the bytes read before returning the result. This interface
  1545. * accomodates the 'N' command in the boot shell. If an unknown unit
  1546. * number is passed, then an ethernet address of all zeros is returned.
  1547. *
  1548. * RETURNS: N/A
  1549. */
  1551. void sysEnetAddrGet
  1552.     (
  1553.     int unit,                   /* Unit number */
  1554.     uchar_t* retEnetAddr        /* Returned ethernet addr */
  1555.     )
  1556.     {                               
  1557.     uchar_t readEnetAddr [ENET_SIZE + 1]; /* read from NVRAM, natural order */
  1558.     
  1559.     if (unit == IDT_UNIT0)
  1560.         {
  1561.         sysNvRamGet ((char *) readEnetAddr, ENET_SIZE, NV_ENET_OFFSET0);
  1562.         sysEnetReverse (readEnetAddr, retEnetAddr);
  1563.         }
  1564.     else if (unit == IDT_UNIT1)
  1565.         {
  1566.         sysNvRamGet ((char *) readEnetAddr, ENET_SIZE, NV_ENET_OFFSET0);
  1567.         sysEnetReverse (readEnetAddr, retEnetAddr);
  1568.         retEnetAddr[5]= retEnetAddr[5] + 1;
  1569.         }    
  1570.     else
  1571.         {
  1572.         bfill ((char *) retEnetAddr, ENET_SIZE, 0);
  1573.         }
  1574.     }
  1576. /**************************************************************************
  1577. *
  1578. * sysEnetAddrSet - Write ethernet address to NVRAM for boot shell.
  1579. *
  1580. * This routine writes the passed ethernet address to NVRAM. For a
  1581. * given address 00:11:22:33:44:55, the parameter order would be
  1582. * sysEnetAddrSet(00,11,22,33,44,55). This interface accomodates the
  1583. * 'N' command in the boot shell.
  1584. *
  1585. * RETURNS: N/A
  1586. */
  1588. void sysEnetAddrSet
  1589.     (
  1590.      
  1591.     uchar_t    addr0,           /* Address offset 0 - first byte of address */
  1592.     uchar_t    addr1,           /* Address offset 1 */
  1593.     uchar_t    addr2,           /* Address offset 2 */
  1594.     uchar_t    addr3,           /* Address offset 3 */
  1595.     uchar_t    addr4,           /* Address offset 4 */
  1596.     uchar_t    addr5            /* Address offset 5 - last byte of address */
  1597.     )
  1598.     {
  1599.     char enetAddr [ENET_SIZE];
  1601.     enetAddr [0] = addr0;
  1602.     enetAddr [1] = addr1;
  1603.     enetAddr [2] = addr2;
  1604.     enetAddr [3] = addr3;
  1605.     enetAddr [4] = addr4;
  1606.     enetAddr [5] = addr5;
  1607.     
  1608.     
  1609.     sysNvRamSet ((char *) enetAddr, ENET_SIZE, NV_ENET_OFFSET0);
  1610.     
  1611.     }
  1613. /******************************************************************************
  1614. *
  1615. * sysidt32438EnetAddrGet - Retrieve ethernet address for ethernet driver.
  1616. *
  1617. * This routine returns a six-byte ethernet address for a given ethernet unit.
  1618. * The ethernet driver uses this routine to obtain the ethernet address if
  1619. * indicated by a user-flag in the LoadString (above) - or if the reading the
  1620. * ethernet address ROM is unsuccessful.
  1621. *
  1622. * RETURNS: OK
  1623. */
  1625. STATUS sysidt32438EnetAddrGet
  1626.     (
  1627.     int         unit,        /* unit number */
  1628.     char *      enetAddr     /*returned ethernet address */
  1629.     )
  1630.     {
  1631.    
  1632.     sysNvRamGet (enetAddr, ENET_SIZE, NV_ENET_OFFSET0);
  1633.     
  1634.     return (OK);
  1635.     }
  1638. /**************************************************************************
  1639. *
  1640. * sysEnetAddrInit - Initialize NVRAM with default ethernet address
  1641. *
  1642. * This routine checks the ethernet address stored in NVRAM. If the
  1643. * first three bytes are not set to the unused manufacturing code
  1644. * (ENET_DEFAULT, defined in config.h), then a default address
  1645. * is written into NVRAM which comprises the unused manufacturing code
  1646. * and 3 lower bytes of 0xff.
  1647. *
  1648. * RETURNS: N/A
  1649. */
  1651. void sysEnetAddrInit (void)
  1652.     {
  1653.     char defEnetAddr [ENET_SIZE] = /* Default ethernet address */
  1654.         {
  1655.         ((ENET_DEFAULT & 0x0000ff00) >> 8),
  1656.         ((ENET_DEFAULT & 0x00ff0000) >> 16),
  1657.         ((ENET_DEFAULT & 0xff000000) >> 24),
  1658.         0xff, 0xff, 0xff
  1659.         };
  1660.     char curEnetAddr [ENET_SIZE + 1]; /* Current ethernet address */
  1662.     /* Read current ethernet address */
  1663.     
  1664.     sysNvRamGet(curEnetAddr, ENET_SIZE, NV_ENET_OFFSET0);
  1666.     /* If first three bytes of current ethernet address are not
  1667.      * ENET_DEFAULT, then write default address.
  1668.      */
  1669.      
  1670.     if ((curEnetAddr[0] != defEnetAddr[0]) 
  1671.        ||  (curEnetAddr[1] != defEnetAddr[1])
  1672.        ||  (curEnetAddr[2] != defEnetAddr[2])
  1673.        )
  1674.        {
  1675.        sysNvRamSet (defEnetAddr, ENET_SIZE, NV_ENET_OFFSET0);
  1676.        }
  1677.     }
  1679.  
  1681. #ifdef  INCLUDE_TIMESTAMP
  1683. /*******************************************************************************
  1684. *
  1685. * sysTimestampConnect - connect a user routine to a timestamp timer interrupt
  1686. *
  1687. * This routine specifies the user interrupt routine to be called at each
  1688. * timestamp timer interrupt.
  1689. *
  1690. * RETURNS: ERROR, always.
  1691. */
  1693. STATUS sysTimestampConnect
  1694.     (
  1695.     FUNCPTR routine,    /* routine called at each timestamp timer interrupt */
  1696.     int arg             /* argument with which to call routine */
  1697.     )
  1698.     {
  1699.     return (ERROR);
  1700.     }
  1702. /*******************************************************************************
  1703. *
  1704. * sysTimestampEnable - enable a timestamp timer interrupt
  1705. *
  1706. * This routine enables timestamp timer interrupts and resets the counter.
  1707. *
  1708. * RETURNS: OK, always.
  1709. *
  1710. * SEE ALSO: sysTimestampDisable()
  1711. */
  1713. STATUS sysTimestampEnable (void)
  1714.    {
  1715.    if (sysTimestampRunning)
  1716.       {
  1717.       return (OK);
  1718.       }
  1720.    if (!sysClkRunning)
  1721.       return (ERROR);
  1723.    sysTimestampRunning = TRUE;
  1725.    return (OK);
  1726.    }
  1728. /*******************************************************************************
  1729. *
  1730. * sysTimestampDisable - disable a timestamp timer interrupt
  1731. *
  1732. * This routine disables timestamp timer interrupts.
  1733. *
  1734. * RETURNS: OK, always.
  1735. *
  1736. * SEE ALSO: sysTimestampEnable()
  1737. */
  1739. STATUS sysTimestampDisable (void)
  1740.     {
  1741.     if (sysTimestampRunning)
  1742.         sysTimestampRunning = FALSE;
  1744.     return (OK);
  1745.     }
  1747. /*******************************************************************************
  1748. *
  1749. * sysTimestampPeriod - get the period of a timestamp timer
  1750. *
  1751. * This routine gets the period of the timestamp timer, in ticks.  The
  1752. * period, or terminal count, is the number of ticks to which the timestamp
  1753. * timer counts before rolling over and restarting the counting process.
  1754. *
  1755. * RETURNS: The period of the timestamp timer in counter ticks.
  1756. */
  1758. UINT32 sysTimestampPeriod (void)
  1759.     {
  1760.     /*
  1761.      * The period of the timestamp depends on the clock rate of the on-chip
  1762.      * timer.
  1763.      */
  1765.     return (CPU_CLOCK_RATE/sysClkTicksPerSecond);
  1766.     }
  1768. /*******************************************************************************
  1769. *
  1770. * sysTimestampFreq - get a timestamp timer clock frequency
  1771. *
  1772. * This routine gets the frequency of the timer clock, in ticks per
  1773. * second.  The rate of the timestamp timer is set explicitly by the
  1774. * hardware and typically cannot be altered.
  1775. *
  1776. * RETURNS: The timestamp timer clock frequency, in ticks per second.
  1777. */
  1779. UINT32 sysTimestampFreq (void)
  1780.     {
  1781.     return (CPU_CLOCK_RATE);
  1782.     }
  1784. /*******************************************************************************
  1785. *
  1786. * sysTimestamp - get a timestamp timer tick count
  1787. *
  1788. * This routine returns the current value of the timestamp timer tick counter.
  1789. * The tick count can be converted to seconds by dividing it by the return of
  1790. * sysTimestampFreq().
  1791. *
  1792. * This routine should be called with interrupts locked.  If interrupts are
  1793. * not locked, sysTimestampLock() should be used instead.
  1794. *
  1795. * RETURNS: The current timestamp timer tick count.
  1796. *
  1797. * SEE ALSO: sysTimestampFreq(), sysTimestampLock()
  1798. */
  1800. UINT32 sysTimestamp (void)
  1801.     {
  1802.     return (sysCountGet() - (sysSoftCompare - sysClkProcessorTicks) + 1);
  1803.     }
  1805. /*******************************************************************************
  1806. *
  1807. * sysTimestampLock - lock interrupts and get the timestamp timer tick count
  1808. *
  1809. * This routine locks interrupts when the tick counter must be stopped
  1810. * in order to read it or when two independent counters must be read.
  1811. * It then returns the current value of the timestamp timer tick
  1812. * counter.
  1813. *
  1814. * The tick count can be converted to seconds by dividing it by the return of
  1815. * sysTimestampFreq().
  1816. *
  1817. * If interrupts are already locked, sysTimestamp() should be
  1818. * used instead.
  1819. *
  1820. * RETURNS: The current timestamp timer tick count.
  1821. *
  1822. * SEE ALSO: sysTimestampFreq(), sysTimestamp()
  1823. */
  1825. UINT32 sysTimestampLock (void)
  1826.     {
  1827.     return(sysCountGet() - (sysSoftCompare - sysClkProcessorTicks)+ 1);
  1828.     }
  1830. #endif  /* INCLUDE_TIMESTAMP */
  1831. #ifdef BROADCOM_BSP
  1832. /******************************************************************************
  1833. *
  1834. * sysBacktraceMips - perform a stack trace of the caller with symbols
  1835. *  by Curt McDowell - csm@broadcom.com 03-20-01
  1836. *
  1837. * NOTE:
  1838. * 
  1839. * This routine is specific to MIPS and GCC stack frame generation.
  1840. * Each function generated by the compiler must begin with a decrement
  1841. * of the stack pointer, then in the next few instructions, must save
  1842. * the return address on the stack.
  1843. *
  1844. *   27bdffd0    addiu       $sp,$sp,-48
  1845. * ...
  1846. *   afbf0028    sw          $ra,40($sp)
  1847. * ...
  1848. */
  1850. /* Hack; some day fix to locate function start using symFindByValue */
  1851. #define SYSBT_MAX_FUNC_WORDS 4096
  1853. LOCAL void sysbt_addr2sym(char *symName, UINT addr)
  1854. {
  1855.     extern SYMTAB_ID sysSymTbl;
  1856.     UINT symVal;
  1857.     SYM_TYPE symType;
  1858.     int                 rc;
  1860. #if VX_VERSION==55
  1861.     char                **psymName;
  1862.     
  1863.     rc = symByValueFind(sysSymTbl,
  1864.        (UINT) addr,
  1865.        psymName, &symVal, &symType);
  1866.     if (rc != ERROR)
  1867.         strcpy(symName, *psymName);        
  1868. #else
  1869.     rc = symFindByValue(sysSymTbl,
  1870.        (UINT) addr,
  1871.        symName, &symVal, &symType);
  1872. #endif
  1873.     if (rc == ERROR)
  1874.         sprintf(symName, "0x%x", addr);
  1875.     else if (symVal < addr)
  1876. sprintf(symName + strlen(symName),
  1877. " + 0x%x", addr - symVal);
  1878.     else if (symVal > addr)
  1879. sprintf(symName + strlen(symName),
  1880. " - 0x%x", symVal - addr);
  1881. }
  1883. #define VALID_K0(addr) 
  1884. (IS_KSEG0(addr) && K0_TO_PHYS(addr) < K0_TO_PHYS(sysPhysMemTop()))
  1885. #define VALID_K1(addr) 
  1886. (IS_KSEG1(addr) && K1_TO_PHYS(addr) < K0_TO_PHYS(sysPhysMemTop()))
  1887. #define VALID_ADDR(addr) 
  1888. (VALID_K0(addr) || VALID_K1(addr))
  1889. #define VALID_TEXT_ADDR(addr) 
  1890. VALID_ADDR(addr) /* some day fix for text range */
  1891. #define VALID_STACK_ADDR(addr) 
  1892. VALID_ADDR(addr) /* some day fix for stack range */
  1894. void sysBacktraceMips(char *pfx, char *sfx, int direct)
  1895. {
  1896.     UINT *sp, *pc, *fn_start, *caller_sp, *ra;
  1897.     extern UINT *vxSpGet(), *vxPcGet(); /* sysALib.s */
  1898.     int limit, first = 1;
  1899.     char buf[2048], symName[128], *s;
  1900.     int ra_off, sp_off;
  1901.     extern void sysSerialPrintString(char *s);
  1903.     sp = vxSpGet();
  1904.     pc = vxPcGet();
  1906.     s = buf;
  1908.     strcpy(s, pfx);
  1909.     while (*s) s++;
  1911.     while (s < &buf[sizeof (buf) - 128]) {
  1912. fn_start = pc;
  1913. for (limit = 0; limit < SYSBT_MAX_FUNC_WORDS; limit++) {
  1914.     /* sw $ra,x($sp); x>=0 */
  1915.     if ((*--fn_start & 0xffff8000) == 0xafbf0000)
  1916. break;
  1917. }
  1918. if (limit == SYSBT_MAX_FUNC_WORDS)
  1919.     break;
  1920. ra_off = (*fn_start & 0x7fff);
  1921. for (limit = 0; limit < SYSBT_MAX_FUNC_WORDS; limit++) {
  1922.     /* addiu $sp,$sp,-x; x<0 */
  1923.     if ((*--fn_start & 0xffff8000) == 0x27bd8000)
  1924. break;
  1925. }
  1926. if (limit == SYSBT_MAX_FUNC_WORDS)
  1927.     break;
  1928. sp_off = (int) (*fn_start | 0xffff0000);
  1929. ra = (UINT *) sp[ra_off / 4];
  1930. caller_sp = sp - (sp_off / 4);
  1931. sysbt_addr2sym(symName, (UINT) pc);
  1932. if (! first)
  1933.     sprintf(s,
  1934.     "FUNC = 0x%x, PC = 0x%x (%s), SP = 0x%xn",
  1935.     (UINT) fn_start, (UINT) pc, symName, (UINT) sp);
  1936. while (*s) s++;
  1937. if (! VALID_TEXT_ADDR(ra)) {
  1938.     sprintf(s, "RA 0x%x out of rangen", (UINT) ra);
  1939.     while (*s) s++;
  1940.     break;
  1941. }
  1942. if (! VALID_STACK_ADDR(caller_sp)) {
  1943.     sprintf(s, "Caller SP 0x%x out of rangen", (UINT) caller_sp);
  1944.     while (*s) s++;
  1945.     break;
  1946. }
  1947. pc = ra;
  1948. sp = caller_sp;
  1949. first = 0;
  1950.     }
  1952.     strcpy(s, sfx);
  1954.     if (direct)
  1955. sysSerialPrintString(buf);  /* Atomically print giant string */
  1956.     else {
  1957. fputs(buf, stdout); /* Regular print giant string */
  1958. fflush(stdout);
  1959.     }
  1960. }
  1963. /*******************************************************************************
  1964. *
  1965. * sysToMonitor - transfer control to the ROM monitor
  1966. *
  1967. * This routine transfers control to the ROM monitor.  Normally, it is called
  1968. * only by reboot()--which services ^X--and bus errors at interrupt level.
  1969. * However, in some circumstances, the user may wish to introduce a
  1970. * <startType> to enable special boot ROM facilities.
  1971. *
  1972. * RETURNS: Does not return.
  1973. */
  1976. int sysToMonitorExcMessage = 0;
  1977. int sysToMonitorBacktrace = 1;
  1978. int sysToMonitorReboot = 1;
  1979. void (*sysToMonitorHook)(void);
  1981. STATUS sysToMonitor
  1982.     (
  1983.     int startType    /* parameter passed to ROM to tell it how to boot */
  1984.     )
  1985.     {
  1986.     if (sysToMonitorHook)
  1987.         (*sysToMonitorHook)();
  1989.     if (sysToMonitorBacktrace)
  1990.         sysBacktraceMips("n--- Stack Trace ---n", "", 1);
  1992.     if (sysToMonitorReboot) {
  1993.         FUNCPTR pRom = (FUNCPTR) (ROM_TEXT_ADRS + 8);
  1994.         intLock();
  1996.         sysWbFlush ();   /* Flush write buffers */
  1998.         (*pRom) (startType);
  2000.         return (OK);    /* in case we ever continue from rom monitor */
  2001.     }
  2002.     return (OK);
  2003.     }
  2006. /*******************************************************************************
  2007. *
  2008. * sysReboot - Reboots the system
  2009. *
  2010. *
  2011. * RETURNS: Does not return.
  2012. */
  2013. void sysReboot
  2014.     (
  2015.     void
  2016.     )
  2017. {
  2018.     sysToMonitor(0);
  2019. }
  2021. void
  2022. SYS_TOD_SET()
  2023. {
  2024. }
  2026. void
  2027. sysSerialPrintString()
  2028. {
  2029. }
  2031. /* Detect HHB4 / DC21150 PCI-PCI bridge chips, and configure bus if
  2032.  * found. Note that this code should be run whenever we find a PCI
  2033.  * class code of type bridge. After we have run this procedure for the
  2034.  * first bridge, we then need to traverse any sub-bridges. This code
  2035.  * deals with only one PCI-PCI bridge and it's IO space for
  2036.  * sub-devices. See mousse.h for more details as well as the PCI-PCI
  2037.  * bridge specification.
  2038.  */
  2039. #ifdef INCLUDE_PCI
  2040. int sysPCIBridgeProbe(int instance,
  2041.       int primary,
  2042.       int secondary,
  2043.       int subordinate)
  2044. {
  2045.     int BusNo, DevNo, FuncNo;
  2046.     unsigned int buses = 0;
  2047.     sysPciBusErrDisable();    
  2048.     /* Find DC21150 PCI-PCI bridge or
  2049.      * HINTCORP HB4 PCI-PCI Bridge
  2050.      */
  2051.     if ( (pciFindDevice(DC21150_VENDOR_ID,
  2052. DC21150_DEVICE_ID,
  2053. instance,
  2054. &BusNo, &DevNo, &FuncNo) != ERROR) ||
  2056.          (pciFindDevice(PERICOM_VENDOR_ID,
  2057.                         PERICOM_8150_DEV_ID,
  2058.                         instance,
  2059.                         &BusNo, &DevNo, &FuncNo) != ERROR) ||
  2061.  (pciFindDevice(HINT_HB4_VENDOR_ID,
  2062. HINT_HB4_DEVICE_ID,
  2063. instance,
  2064. &BusNo, &DevNo, &FuncNo) != ERROR)) {
  2066. /* Disable device */
  2067. pciConfigOutWord(BusNo,DevNo,FuncNo, PCI_CFG_COMMAND, 0x0000);
  2068. pciConfigOutWord(BusNo,DevNo,FuncNo, PCI_CFG_STATUS, 0xffff);
  2070. /* Reset secondary bus */
  2071. pciConfigOutWord(BusNo,DevNo,FuncNo,
  2072.  PCI_CFG_BRIDGE_CONTROL,
  2073.  0x0040);
  2075. /* Setup topology info */
  2076. buses = (buses & 0xff000000)
  2077.     | ((unsigned int)(primary)     <<  0)
  2078.     | ((unsigned int)(secondary)   <<  8)
  2079.     | ((unsigned int)(subordinate) << 16);
  2080. /*
  2081.  * linux, -We need to blast all three values with a single write.
  2082.  */
  2083. pciConfigOutLong(BusNo, DevNo, FuncNo,
  2084.  PCI_CFG_PRIMARY_BUS, buses);
  2086. /* Clear secondary status */
  2087. pciConfigOutWord(BusNo,DevNo,FuncNo,
  2088.  PCI_CFG_SEC_STATUS, 0xffff);
  2090. /* Setup memory address space mapping */
  2091. pciConfigOutWord(BusNo,DevNo,FuncNo,     
  2092.  PCI_CFG_MEM_BASE,
  2093.  ((P2P_NONPREF_MEM_BASE & 0xFFF00000) >> 16));
  2095. pciConfigOutWord(BusNo,DevNo,FuncNo,
  2096.  PCI_CFG_MEM_LIMIT,
  2097.  ((P2P_NONPREF_MEM_BASE +
  2098.    P2P_NONPREF_MEM_SIZE - 1) & 0xFFF00000) >> 16);
  2100. /* Clear bridge control */
  2101. pciConfigOutWord(BusNo,DevNo,FuncNo,
  2102.  PCI_CFG_BRIDGE_CONTROL,0x0000);
  2104. /* Enable PCI clocks on remote end */
  2105. pciConfigOutWord(BusNo,DevNo,FuncNo,
  2106.  PCI_CFG_DEC21150_SEC_CLK,
  2107.  P2P_CLK_ENABLE);
  2109. /* Clear status */
  2110. pciConfigOutByte(BusNo,DevNo,FuncNo,
  2111.  PCI_CFG_DEC21150_SERR_STAT, 0xff);
  2113. /* Clear status */
  2114. pciConfigOutWord(BusNo,DevNo,FuncNo,
  2115.  PCI_CFG_STATUS, 0xffff);
  2117. /* Re-enable config space */
  2118. pciConfigOutWord(BusNo,DevNo,FuncNo, PCI_CFG_COMMAND,
  2119.  P2P_PMC_ENABLE);
  2120.      
  2121. return OK;
  2122.     }    
  2123.     sysPciBusErrEnable();    
  2124.     return ERROR;
  2125. }
  2127. #endif
  2128. /*****************************************************************************
  2129. *
  2130. * Each time VxWorks is rebooted, it starts assigning system-assigned
  2131. * port numbers beginning at 1024.  Thus, if vxWorks is rebooted two or
  2132. * more times in succession, the same port number will be re-used.
  2133. *
  2134. * This behavior causes problems when vxWorks is being booted from a
  2135. * remote FTP server (particularly one running Solaris), because port
  2136. * 1024 goes into a TIME_WAIT state on the server and cannot be reused
  2137. * until it times out, typically in 2-4 minutes.
  2138. *
  2139. * This hack reduces the likelihood of this happening by "wasting"
  2140. * a different number of system-assigned port numbers for each boot.
  2141. */
  2143. void sysBindFix(void)
  2144. {
  2145.     UINT8 N;
  2147.     sysNvRamGet((char *) &N, 1, NV_OFF_BINDFIX);
  2148.     N -= 16;
  2149.     sysNvRamSet((char *) &N, 1, NV_OFF_BINDFIX);
  2151.     /* This is quite fast even when N=255 */
  2153.     while (N--) {
  2154. int s;
  2155. struct sockaddr_in saddr;
  2156. saddr.sin_addr.s_addr = htonl(INADDR_ANY);
  2157. saddr.sin_port = 0;
  2158. saddr.sin_family = AF_INET;
  2159. s = socket(AF_INET, SOCK_STREAM, 0);
  2160. bind(s, (struct sockaddr *) &saddr, sizeof(saddr));
  2161. close(s);
  2162.     }
  2163. }
  2165. #ifdef PCI_DECOUPLED
  2166. #define MAX_POLL_PCI_DECOUPLED  256
  2167. UINT32 sysMaxPciRpolls = 0;
  2168. UINT32 sysMaxPciWpolls = 0;
  2169. UINT32 sysMaxPciRpollsDist[256] = { 0 };
  2172. #ifdef INCLUDE_PCI
  2173. void
  2174. sysPciRWInit()
  2175. {
  2176.     PCI.pcidac  = PCIDAC_DEN;  /* Enable PCI decoupled accesses at */
  2177.                                /* initialization */
  2178.     for(sysMaxPciRpolls = 0;
  2179.         sysMaxPciRpolls < sizeof(sysMaxPciRpollsDist)/sizeof(UINT32);
  2180.         sysMaxPciRpolls++) {
  2181.             sysMaxPciRpollsDist[sysMaxPciRpolls] = 0;
  2182.         }
  2183.     sysMaxPciRpolls = 0;
  2184.     sysMaxPciWpolls = 0;
  2185. }
  2187. UINT32
  2188. sysPciRead(UINT32 *addr)
  2189. {
  2190.     volatile UINT32 data;
  2191.     UINT32 spl;
  2192.     UINT32 cpolls = 0;
  2194.     spl = intLock();
  2195.     data = *addr;
  2196.     while (((PCI.pcidas) & PCIDAS_D) == 0) {
  2197.         if (sysMaxPciRpolls < ++cpolls ) sysMaxPciRpolls = cpolls;
  2198.         if (((PCI.pcidas) & PCIDAS_E) != 0) break;
  2199.         if (cpolls > MAX_POLL_PCI_DECOUPLED) break;
  2200.     }
  2202.     if (cpolls < sizeof(sysMaxPciRpollsDist)/sizeof(UINT32)) {
  2203.         sysMaxPciRpollsDist[cpolls]++; 
  2204.     }
  2205.     data = PCI.pcidad;
  2206.     data = ((data & 0xFF000000) >> 24) |
  2207.            ((data & 0x00FF0000) >> 8) |
  2208.            ((data & 0x0000FF00) << 8) |
  2209.            ((data & 0x000000FF) << 24) ;
  2210.     PCI.pcidas &= (~(PCIDAS_D));
  2211.     intUnlock(spl);
  2213.     return(data);
  2214. }
  2216. void
  2217. sysPciWrite(UINT32 *addr, UINT32 data)
  2218. {
  2219.     UINT32 spl;
  2220.     UINT32 cpolls = 0;
  2222.     spl = intLock();
  2224.     while ((PCI.pcidas & PCIDAS_OFE) == 0) {
  2225.         if (sysMaxPciWpolls < ++cpolls ) sysMaxPciWpolls = cpolls;
  2226.         if (cpolls > MAX_POLL_PCI_DECOUPLED) break;
  2227.     }
  2229.     *addr = data;
  2230.     cpolls = 0;
  2232.     intUnlock(spl);
  2233. }
  2234. #endif
  2235. #endif /* PCI_DECOUPLED */
  2236. #endif /*BROADCOM_BSP */