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

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

VxWorks

开发平台：

C/C++

sysEpic.c：源码内容
  1. /* sysEpic.c - Driver for Embedded Programmable Interrupt Controller */
  3. /*
  4.  * Copyright (c) 2005-2006 Wind River Systems, Inc.
  5.  *
  6.  * The right to copy, distribute, modify, or otherwise make use
  7.  * of this software may be licensed only pursuant to the terms
  8.  * of an applicable Wind River license agreement.
  9.  */
  11. /*
  12. modification history
  13. --------------------
  14. 01b,27jan06,dtr  Tidyup and minor changes.
  15. 01a,08oct05,dtr  Created based on cds85xx/01h.
  16. */
  18. /*
  19. DESCRIPTION
  20. This module implements the Embedded Programmable Interrupt Controller (EPIC)
  21. driver for the MPC8548.
  23. The EPIC is an integrated interrupt controller in the 8548 which
  24. provides following major capabilities:
  26.   Support for twelve external interrupt sources and thirty-two internal
  27.   interrupt sources
  29.   Support for connection of external interrupt controller device e.g. 8259
  30.   like as implemented on a WinBond chip
  31.      
  32.   12 external interrupt sources
  33.   32 internal interrupt sources
  34.   16 programmable interrupt priority levels
  35.   Fully-nested interrupt delivery
  36.   Spurious vector generation
  37.   Route to critical interrupt destinations
  38.   Route to external pin
  39.   Configurable sense and polarity at initialization and runtime
  41. The current implementation of this EPIC controller does not support
  42. the following features or mode of operations:
  44.   PIC global timers
  45.   Inter-processor interrupts
  46.   Messaging interrupts
  48. EPIC features are customized by writing into general control registers
  49. or into interrupt level specific registers (IVPRs).
  51. This driver allows a basic interface to the EPIC such as initializing it,
  52. setting interrupt vectors, priorities, level/edge sense and interrupt
  53. polarities, as well as enabling and disabling specific interrupts.
  55. This driver implements a complete interrupt architecture system, complete
  56. with vector table.
  58. Since interrupt vectors can be shared, this driver does provide for
  59. overloading of interrupt routines (i.e. there is
  60. a list of interrupt routines for each interrupt vector (level)).  To service
  61. a vector requires that all connected interrupt routines be called in order
  62. of their connection.
  64. The following diagram shows an example of how interrupts can
  65. be configured in this system.
  67.     EPIC Vector table
  68. 0  |-------|  <-- external INT0 starts
  69.    |-------|
  70.    |-------|------------------------------+
  71.     ....                                  |
  72.    |-------|                              |
  73.    |-------|                              |
  74. 12 |-------| <-- internal INT0 starts     |   (EPIC_MAX_EXT_IRQS) = 12
  75.    |-------|                              |
  76.    |-------|                              |
  77.     ....                                  |
  78.    |-------|                              |
  79.    |-------|                              |
  80. 44 |-------| <-- global timer INT0 starts |   (EPIC_MAX_EXT_IRQS + 
  81.    |-------|                              |    EPIC_MAX_IN_IRQS) = 44
  82.    |-------|                              |
  83.    |-------|                              |
  84. 48 |-------| <-- message INT0 starts      |   (EPIC_MAX_EXT_IRQS + 
  85.    |-------|                              |    EPIC_MAX_IN_IRQS + 
  86.    |-------|                              |    EPIC_MAX_GT_IRQS) = 48
  87.    |-------|                              |
  88. 52 |-------| <-- IPI INT0 starts          |   (EPIC_MAX_EXT_IRQS + 
  89.    |-------|                              |    EPIC_MAX_IN_IRQS + 
  90.    |-------|                              |    EPIC_MAX_GT_IRQS + 
  91. 55 |-------|                              |    EPIC_MAX_MSG_IRQS) = 52
  92. 56 |-------|<-----------------------------+   sysVectorIRQ0 = 56 
  93.     ....         WinBond int handler      |   = 52 + EPIC_MAX_IPI_IRQS
  94.    |-------|                              +-------------+
  95.    |-------|                                            |
  96.    |-------|                                 PCI slot 3 int handler
  97.    |-------|
  98.    |-------|<----- Cascaded 8259s
  99.    |-------|
  100.    |-------|
  101.     ....
  102.    |-------|
  103.    |-------|
  104.    |-------|
  105.    |-------|
  106. 256|-------|
  108. The driver is designed to put external interrupts at the beginning of the
  109. vector table.  As a result, devices that route their interrupt to the EPIC
  110. on the MPC8540 does not need to translate the vector number.  Therefore,
  111. the macros IVEC_TO_INUM(x) and INUM_TO_IVEC(x) are not necessary.  For
  112. some existing drivers, it may be necessary to use the following defines:
  113.   #undef  INUM_TO_IVEC
  114.   #define INUM_TO_IVEC(x) (x)
  115.   #undef  IVEC_TO_INUM
  116.   #define IVEC_TO_INUM(x) (x)
  118. If there are other devices in the system capable of generating their own
  119. vectors then we presume that an appropriate interrupt handler is created
  120. and attached to the vector associated with the correct IRQ number.  That
  121. interrupt handler would get a new vector directly from the device and then
  122. call all of the handlers attached to that new vector.  Vector information is
  123. stored in a linked list of INT_HANDLER_DESC structures. The sysIntTbl array
  124. contains a pointer to the first entry for each vector.
  126. INITIALIZATION
  128. This driver is initialized from the BSP, usually as part of sysHwInit().
  129. The first routine to be called is sysEpicInit(). The routine resets the
  130. global configuration register and resets the epic registers to default
  131. values.
  133. The second routine to be called is sysEpicIntrInit().  This routine takes no
  134. arguments. This routine allocates the vector table and initializes the
  135. chips to a default state.  All individual interrupt sources are disabled.
  136. Each has to be individually enabled by intEnable() before it will be
  137. unmasked and allowed to generate an interrupt.
  139. CRITICAL INTERRUPT
  141. To enable the EPIC to handle also critical interrupt, or if a normal
  142. interrupt is to be rerouted to the critical input pin, INCLUDE_EPIC_CRT_INTR
  143. should be defined.  e.g. Define the following in config.h:
  144.   #define INCLUDE_EPIC_CRT_INTR     /@ include critical interrupt support @/
  146. The critical interrupt handler uses information from the summary registers
  147. CISR0 and CISR1.  The EPIC does not manage critical interrupts and hence
  148. Iack or EOI do not apply.  It was seen that the summary registers go
  149. through a transient state before settling on the result.  This causes
  150. spurious interrupts to be generated, and the vectors being called.
  151. A typical behavior is the printout of "uninitialized PIC interrupt
  152. vector 0xXX".  This is observed only when at least one source has been
  153. routed to critical pin.
  155. CUSTOMIZING THIS DRIVER
  157. The BSP can change the default polarity and sensitivity for the external
  158. interrupt and the internal interrupt independently.  They are:
  159.   EPIC_EX_DFT_SENSE /@ default to EPIC_SENSE_LVL @/
  160.   EPIC_EX_DFT_POLAR     /@ default to EPIC_INT_ACT_HIGH @/
  161.   EPIC_IN_DFT_POLAR     /@ default to EPIC_INT_ACT_HIGH @/
  162. If any of the above is defined before the inclusion of sysEpic.h, such as
  163. in config.h, the default will be overridden.  The available options are:
  164.   EPIC_EX_DFT_SENSE     EPIC_SENSE_LVL, EPIC_SENSE_EDG
  165.   EPIC_xx_DFT_POLAR     EPIC_INT_ACT_LOW, EPIC_INT_ACT_HIGH /@if level-sense @/
  166.                         EPIC_INT_EDG_NEG, EPIC_INT_EDG_POS  /@if edge-sense @/
  168. The macros CPU_INT_LOCK() and CPU_INT_UNLOCK provide the access
  169. to the CPU level interrupt lock/unlock routines.  We presume that there
  170. is a single interrupt line to the CPU.  By default these macros call
  171. intLock() and intUnlock() respectively.
  173. INCLUDE FILES:
  174. */
  176. /* includes */
  178. #include <vxWorks.h>
  179. #include "config.h"
  180. #include "sysEpic.h"
  182. #include <sysLib.h>
  183. #include <stdio.h>
  184. #include <string.h>
  186. #ifdef INCLUDE_WINDVIEW
  187. #include <private/eventP.h>
  188. #endif
  190. /* defines */
  192. #ifndef CPU_INT_LOCK
  193. #   define CPU_INT_LOCK(pData) 
  194. (*pData = intLock ())
  195. #endif
  197. #ifndef CPU_INT_UNLOCK
  198. #   define CPU_INT_UNLOCK(data) 
  199. (intUnlock (data))
  200. #endif
  202. /* externs */
  204. IMPORT STATUS  excIntConnect (VOIDFUNCPTR *, VOIDFUNCPTR);
  205. IMPORT STATUS  excIntCrtConnect (VOIDFUNCPTR *, VOIDFUNCPTR);
  208. /* get the interrupt hook routines  prototypes*/
  210. IMPORT STATUS (*_func_intConnectRtn) (VOIDFUNCPTR *, VOIDFUNCPTR, int);
  211. IMPORT int (*_func_intEnableRtn)  (int);
  212. IMPORT int (*_func_intdisableRtn) (int);
  214. /* globals */
  216. INT_HANDLER_DESC * sysIntTbl [INTERRUPT_TABLESIZE]; /* system interrupt tbl */
  218. /* locals */
  220. /* forward declarations */
  222. LOCAL int epicIntEnable (ULONG srcAddr);
  223. LOCAL int epicIntDisable (ULONG srcAddr);
  224. LOCAL int epicVecOptionsSet (ULONG srcAddr, UINT32 mask, UINT32 options);
  225. LOCAL UINT32 epicVecOptionsGet (ULONG srcAddr);
  226. LOCAL void sysEpicIntHandlerExec (int vector);
  227. LOCAL void  sysEpicIntHandler (void);
  228. #ifdef INCLUDE_EPIC_CRT_INTR
  229. LOCAL void  sysEpicCrtIntHandler (void);
  230. LOCAL int epicCrtIntSet (ULONG srcAddr);
  231. LOCAL int epicCrtIntUnset (ULONG srcAddr);
  232. LOCAL int epicCrtIntGet (ULONG srcAddr);
  233. #endif  /* INCLUDE_EPIC_CRT_INTR */
  234. LOCAL int       epicSrcAddrCheck (ULONG srcAddr);
  236. /*******************************************************************************
  237. *
  238. * sysEpicInit - initialize the epic controller
  239. *
  240. * This routine resets the global Configuration Register, thus it:
  241. *  -  disables all interrupts
  242. *  -  sets epic registers to reset values
  243. *
  244. * It then sets the EPIC operation mode to Mixed Mode (vs. Pass Through
  245. * mode). At this point only mixed mode is supported which means the EPIC
  246. * is not configured for the pass through mode.
  247. *
  248. * Only direct interrupt sources is supported by the PIC.  Serial 
  249. * stype interrupt is not available.
  250. *
  251. * NOMANUAL
  252. * 
  253. * RETURNS: N/A
  254. *
  255. * ERRNO: N/A
  256. */    
  258. void sysEpicInit (void)
  259.     {
  260.     ULONG  gcrVal;
  261.     int  irq;
  263.     gcrVal = sysEpicRegRead (EPIC_GLOBAL_REG);
  265.     gcrVal |= (EPIC_GCR_RESET);
  266.     
  267.     sysEpicRegWrite (EPIC_GLOBAL_REG, gcrVal);
  269.     /* wait for the reset sequence to be completed */
  270.     
  271.     while (sysEpicRegRead (EPIC_GLOBAL_REG) & EPIC_GCR_RESET)
  272.         {
  273.         ; /* do nothing */
  274.         }
  276.     gcrVal = sysEpicRegRead (EPIC_GLOBAL_REG);
  278.     gcrVal |= (EPIC_GCR_MODE_MIXED); /* configure for mixed mode */
  279.     
  280.     sysEpicRegWrite (EPIC_GLOBAL_REG, gcrVal);
  282.     /* Clear all pending interrupt */
  283.     while (((USHORT) epicIntAck()) != (USHORT) 0xffff)
  284.         {
  285.         /* do nothing */
  286. }
  288.     /* init all EIVPRs to sense = 1, polarity = defined, vec = 0, prio = 0 */
  289.     for (irq = 0; irq < EPIC_MAX_EXT_IRQS; irq++)
  290.         {
  291.         epicIntDisable (EPIC_EX_VEC_REG(irq));
  293.         epicIntSourceSet (EPIC_EX_VEC_REG(irq),
  294.                           EPIC_EX_DFT_POLAR, EPIC_EX_DFT_SENSE, 0x0, 0x0);
  295.         }
  297.     /* init all IIVPRs to polarity = defined, vec = 0, prio = 0 */
  298.     for (irq = 0; irq < EPIC_MAX_IN_IRQS; irq++)
  299.         {
  300.         epicIntDisable (EPIC_IN_VEC_REG(irq));
  302.         epicIntSourceSet (EPIC_IN_VEC_REG(irq),
  303.                           EPIC_IN_DFT_POLAR, 0x0, 0x0, 0x0);
  304.         }
  306.     /* init all GTVPRs to vec = 0, prio = 0 */
  307.     for (irq = 0; irq < EPIC_MAX_GT_IRQS; irq++)
  308.         {
  309.         epicIntDisable (EPIC_GT_VEC_REG(irq));
  311.         epicIntSourceSet (EPIC_GT_VEC_REG(irq),
  312.                           0x0, 0x0, 0x0, 0x0);
  313.         }
  315.     /* init all MIVPRs to vec = 0, prio = 0 */
  316.     for (irq = 0; irq < EPIC_MAX_MSG_IRQS; irq++)
  317.         {
  318.         epicIntDisable (EPIC_MSG_VEC_REG(irq));
  320.         epicIntSourceSet (EPIC_MSG_VEC_REG(irq),
  321.                           0x0, 0x0, 0x0, 0x0);
  322.         }
  324.     /* disable IPIs */
  325.     for (irq = 0; irq < EPIC_MAX_IPI_IRQS; irq++)
  326.         {
  327.         epicIntDisable (EPIC_IPI_VEC_REG(irq));
  329.         epicIntSourceSet (EPIC_IPI_VEC_REG(irq),
  330.                           0x0, 0x0, 0x0, 0x0);
  331.         }
  333.     epicCurTaskPrioSet (EPIC_PRIORITY_MAX); /* set it to highest priority */
  334.     }
  336. /*******************************************************************************
  337. *
  338. * sysEpicIntrInit - initialize the interrupt table
  339. *
  340. * This function initializes the interrupt mechanism of the board.
  341. *
  342. * RETURNS: OK, always.
  343. *
  344. * ERRNO: N/A
  345. */
  347. STATUS  sysEpicIntrInit (void)
  348.     {
  349.     int vector;
  350.     int rc;
  352.     /* initialize the interrupt table */
  354.     for (vector = 0; vector < INTERRUPT_TABLESIZE; vector++)
  355.         {
  356. sysIntTbl [vector] = NULL;
  357.         }
  359.     /*
  360.      * connect the interrupt demultiplexer to the PowerPC external 
  361.      * interrupt exception vector.
  362.      * i. e.  put the address of this interrupt handler in
  363.      * the PowerPC's only external interrupt exception vector
  364.      * which is  _EXC_OFF_INTR = 0x500
  365.      * Also connect critical input pin handler _EXC_OFF_CRTL = 0x100.
  366.      */
  368.     rc = excIntConnect ((VOIDFUNCPTR *) _EXC_OFF_INTR, sysEpicIntHandler);
  369. #ifdef INCLUDE_EPIC_CRT_INTR
  370.     rc = excIntCrtConnect ((VOIDFUNCPTR *) _EXC_OFF_CRTL, sysEpicCrtIntHandler);
  371. #endif  /* INCLUDE_EPIC_CRT_INTR */
  373.     /*  
  374.      * set up the BSP specific interrupt routines
  375.      * Attach the local routines to the VxWorks system calls
  376.      *
  377.      */
  379.     _func_intConnectRtn  =  sysEpicIntConnect;
  380.     _func_intEnableRtn   =  sysEpicIntEnable;
  381.     _func_intDisableRtn  =  sysEpicIntDisable;
  383.     epicCurTaskPrioSet (EPIC_PRIORITY_MIN); /* set it to lowest priority */
  384.     
  385.     return (rc);
  386.     }
  389. /*******************************************************************************
  390. *
  391. * sysEpicIntEnable - enable a EPIC interrupt level
  392. *
  393. * This routine enables a specified EPIC interrupt level.
  394. *
  395. * NOMANUAL
  396. *
  397. * RETURNS: OK, ERROR, or EPIC_INV_INTER_SOURCE.
  398. *
  399. * NOTE: To allow compatibility, sysEpicIntEnable() can be used only for
  400. *       external and internal interrupts, and not GT, MSG, IPI.  It
  401. *       assumes there are more internal IRQs than external.  It also
  402. *       gives priority to external over internal given the same IRQ
  403. *       is valid for both external and internal.
  404. *
  405. * ERRNO: N/A
  406. */
  408. int sysEpicIntEnable
  409.     (
  410.     int vector
  411.     )
  412.     {
  413.     if ((vector < 0)  || (vector >= EPIC_MAX_ALL_IRQS))
  414.         return (ERROR);
  416.     /* enable interrupt on EPIC */
  418.     return epicIntEnable ( epicGetVecRegAdrs (vector) );
  419.     }
  421. /*******************************************************************************
  422. *
  423. * sysEpicIntDisable - disable a EPIC interrupt level
  424. *
  425. * This routine disables a specified EPIC interrupt level.
  426. *
  427. * NOMANUAL
  428. *
  429. * RETURNS: OK, ERROR, or EPIC_INV_INTER_SOURCE.
  430. *
  431. * NOTE: To allow compatibility, sysEpicIntDisable() can be used only for
  432. *       external and internal interrupts, and not GT, MSG, IPI.  It
  433. *       assumes there are more internal IRQs than external.  It also
  434. *       gives priority to external over internal given the same IRQ
  435. *       is valid for both external and internal.
  436. *
  437. * ERRNO: N/A
  438. */
  440. int  sysEpicIntDisable
  441.     (
  442.     int vector
  443.     )
  444.     {
  445.     if ((vector < 0) || (vector >= EPIC_MAX_ALL_IRQS))
  446.         return (ERROR);
  448.     /* disable interrupt on EPIC */
  450.     return epicIntDisable ( epicGetVecRegAdrs (vector) );
  451.     }
  453. /*******************************************************************************
  454. *
  455. * epicVecOptionsSet - set options for a vector
  456. *
  457. * <srcAddr> is the address offset of the Vector Priority register
  458. * <mask> is one of EPIC_OPT_EN_MSK, EPIC_OPT_POLAR_MSK, EPIC_OPT_SENSE_MSK,
  459. *                  EPIC_OPT_PRI_MSK, EPIC_OPT_EXPIN_MSK, EPIC_OPT_CRIT_MSK
  460. * <options> is one of 
  461. *   EPIC_OPT_EN_Y              interrupt enabled
  462. *   EPIC_OPT_EN_N              interrupt disabled
  463. *   EPIC_OPT_POLAR_ACT_LOW     polarity is active low
  464. *   EPIC_OPT_POLAR_ACT_HIGH    polarity is active high
  465. *   EPIC_OPT_POLAR_EDG_NEG     polarity is negative edge triggered
  466. *   EPIC_OPT_POLAR_EDG_POS     polarity is positive edge triggered
  467. *   EPIC_OPT_SENSE_EDG         edge sensitive
  468. *   EPIC_OPT_SENSE_LVL         level sensitive
  469. *   EPIC_OPT_PRI_VALUE(p)      set priority to p [0..15]
  470. *   EPIC_OPT_EXPIN_OFF         external pin off
  471. *   EPIC_OPT_EXPIN_ON          external pin on
  472. *   EPIC_OPT_CRIT_OFF          route to critical pin off
  473. *   EPIC_OPT_CRIT_ON           route to critical pin on
  474. *
  475. * NOMANUAL
  476. *
  477. * RETURNS: OK or an error code, can be one of the following:
  478. *          OK
  479. *          ERROR
  480. *          EPIC_VEC_OPTION_INV
  481. *          EPIC_INV_INTER_SOURCE
  482. *          EPIC_VEC_OPTION_NA
  483. *          EPIC_VEC_HAS_NO_IDR
  484. *          EPIC_INTER_IN_SERVICE
  485. *
  486. * ERRNO: N/A
  487. */
  489. LOCAL int epicVecOptionsSet
  490.     (
  491.     ULONG       srcAddr,
  492.     UINT32  mask,
  493.     UINT32  options
  494.     )
  495.     {
  496.     ULONG       vprVal;
  497.     ULONG       idrVal;
  498.     ULONG       vprFlag;
  499.     ULONG       idrFlag;
  500.     int         errCode;
  501.     int         idrOffset = 0;              /* offset of IDR from VPR */
  503.     if ((mask & ((0x3f30 << 16) | (0x3fff))) != 0)
  504.         return (EPIC_VEC_OPTION_INV);
  506.     errCode = epicSrcAddrCheck (srcAddr);
  508.     if (errCode == EPIC_INV_INTER_SOURCE)
  509.         {
  510.         return (errCode);
  511.         }
  513.     vprFlag = mask & 0xffff0000;            /* upper sets upper VPR */
  514.     idrFlag = (mask & 0x0000ffff) << 16;    /* lower sets upper IDR */
  516.     switch (errCode)
  517.         {
  518.         case EPIC_EX_INTERRUPT:
  519.             idrOffset = EPIC_EX_DEST_REG_VECREGOFF;
  520.         break;
  522.         case EPIC_IN_INTERRUPT:
  523.             idrOffset = EPIC_IN_DEST_REG_VECREGOFF;
  524.             if ((vprFlag & EPIC_OPT_SENSE_MSK) != 0)
  525.                 return (EPIC_VEC_OPTION_NA);
  526.         break;
  528.         case EPIC_GT_INTERRUPT:
  529.             if (idrFlag != 0)
  530.                 return (EPIC_VEC_HAS_NO_IDR);
  531.         break;
  533.         case EPIC_MSG_INTERRUPT:
  534.             idrOffset = EPIC_MSG_DEST_REG_VECREGOFF;
  535.             if ((vprFlag & (EPIC_OPT_POLAR_MSK | EPIC_OPT_SENSE_MSK)) != 0)
  536.                 return (EPIC_VEC_OPTION_NA);
  537.         break;
  539.         case EPIC_IPI_INTERRUPT:
  540.             if (idrFlag != 0)
  541.                 return (EPIC_VEC_HAS_NO_IDR);
  542.         break;
  544.         default:
  545.             return (ERROR);
  546.         }
  548.     vprVal = sysEpicRegRead (srcAddr);
  550.     if ((vprVal & EPIC_EIVPR_INTR_ACTIVE) != 0)
  551.         return (EPIC_INTER_IN_SERVICE);
  553.     if (vprFlag != 0)
  554.         {
  555.         vprVal &= ~(vprFlag);
  556.         vprVal |= (options & 0xffff0000);
  557.         sysEpicRegWrite (srcAddr, vprVal);
  558.         }
  560.     if ((idrFlag != 0) && (idrOffset != 0))
  561.         {
  562.         idrVal = sysEpicRegRead (srcAddr + idrOffset);
  563.         idrVal &= ~(idrFlag);
  564.         idrVal |= (options & 0xffff) << 16;
  565.         sysEpicRegWrite (srcAddr + idrOffset, idrVal);
  566.         }
  568.     return OK;
  570.     }
  572. /*******************************************************************************
  573. *
  574. * epicVecOptionsGet - get options for a vector
  575. *
  576. * <srcAddr> is the address offset of the Vector Priority register
  577. *
  578. * Use one or more of the following masks to extract the returned value:
  579. *   EPIC_OPT_EN_MSK
  580. *   EPIC_OPT_POLAR_MSK
  581. *   EPIC_OPT_SENSE_MSK
  582. *   EPIC_OPT_PRI_MSK
  583. *   EPIC_OPT_EXPIN_MSK
  584. *   EPIC_OPT_CRIT_MSK
  585. *
  586. * NOMANUAL
  587. *
  588. * RETURNS: OK, ERROR, or EPIC_INV_INTER_SOURCE
  589. *
  590. * ERRNO: N/A
  591. */
  593. LOCAL UINT32 epicVecOptionsGet
  594.     (
  595.     ULONG       srcAddr
  596.     )
  597.     {
  598.     ULONG       vprVal;
  599.     ULONG       idrVal;
  600.     int         errCode;
  601.     int         idrOffset = 0;              /* offset of IDR from VPR */
  603.     errCode = epicSrcAddrCheck (srcAddr);
  605.     if (errCode == EPIC_INV_INTER_SOURCE)
  606.         {
  607.         return (errCode);
  608.         }
  610.     switch (errCode)
  611.         {
  612.         case EPIC_EX_INTERRUPT:
  613.             idrOffset = EPIC_EX_DEST_REG_VECREGOFF;
  614.         break;
  616.         case EPIC_IN_INTERRUPT:
  617.             idrOffset = EPIC_IN_DEST_REG_VECREGOFF;
  618.         break;
  620.         case EPIC_GT_INTERRUPT:
  621.         break;
  623.         case EPIC_MSG_INTERRUPT:
  624.             idrOffset = EPIC_MSG_DEST_REG_VECREGOFF;
  625.         break;
  627.         case EPIC_IPI_INTERRUPT:
  628.         break;
  630.         default:
  631.             return ((UINT32) ERROR);
  632.         }
  634.     vprVal = sysEpicRegRead (srcAddr);
  635.     if (idrOffset != 0)
  636.         idrVal = sysEpicRegRead (srcAddr + idrOffset);
  637.     else
  638.         idrVal = 0;
  640.     return ((vprVal & 0xffff0000) | (idrVal >> 16));
  641.     }
  643. /*
  644. *
  645. * sysEpicVecOptionsSet - change options for a vector
  646. *
  647. */
  649. int sysEpicVecOptionsSet
  650.     (
  651.     int    vector,
  652.     UINT32 mask,
  653.     UINT32 options
  654.     )
  655.     {
  656.     if ((vector < 0) || (vector >= EPIC_MAX_ALL_IRQS))
  657.         return (ERROR);
  659.     /* set vector options on EPIC */
  661.     return epicVecOptionsSet ( epicGetVecRegAdrs (vector), mask, options );
  662.     }
  664. /*
  665. *
  666. * sysEpicVecOptionsGet - obtain options for a vector
  667. *
  668. */
  670. UINT32 sysEpicVecOptionsGet
  671.     (
  672.     int vector
  673.     )
  674.     {
  675.     if ((vector < 0) || (vector >= EPIC_MAX_ALL_IRQS))
  676.         return ((UINT32) ERROR);
  678.     /* get vector options on EPIC */
  680.     return epicVecOptionsGet ( epicGetVecRegAdrs (vector) );
  681.     }
  683. /*******************************************************************************
  684. *
  685. * sysEpicIntConnect - connect an interrupt handler to the system vector table
  686. *
  687. * This function connects an interrupt handler to the system vector table.
  688. *
  689. * RETURNS: OK or ERROR.
  690. *
  691. * ERRNO: N/A
  692. */
  694. STATUS sysEpicIntConnect
  695.     (
  696.     VOIDFUNCPTR *  vector, /* interrupt vector to attach */
  697.     VOIDFUNCPTR routine, /* routine to be called */
  698.     int parameter /* parameter to be passed to routine */
  699.     )
  700.     {
  701.     INT_HANDLER_DESC * pNewHandler;
  702.     INT_HANDLER_DESC * pCurrHandler;
  703.     int intVal;
  704.     BOOL sharing = FALSE;
  706.     if (((int)vector < 0)  || ((int) vector >= INTERRUPT_TABLESIZE)) 
  707. {
  708.         return (ERROR);   /*  out of range  */
  709. }
  711.     /* create a new interrupt handler */
  713.     pNewHandler = malloc (sizeof (INT_HANDLER_DESC));
  715.     /* check if the memory allocation succeed */
  717.     if (pNewHandler == NULL)
  719. return (ERROR);
  721.     /*  initialize the new handler  */
  723.     pNewHandler->vec = routine;
  724.     pNewHandler->arg = parameter;
  725.     pNewHandler->next = NULL;
  727.     /* install the handler in the system interrupt table  */
  729.     intVal = intLock (); /* lock interrupts to prevent races */
  731.     if (sysIntTbl [(int) vector] == NULL)
  732. {
  733.         sysIntTbl [(int) vector] = pNewHandler;  /* single int. handler case */
  734. }
  735.     else
  736. {
  737.         pCurrHandler = sysIntTbl[(int) vector];/* multiple int. handler case */
  739.         while (pCurrHandler->next != NULL)
  740.             {
  741.             pCurrHandler = pCurrHandler->next;
  742.             }
  743.         
  744.         pCurrHandler->next = pNewHandler;
  746.         sharing = TRUE;
  747. }
  749.     if ((int)vector >= 0 && (int)vector < EPIC_MAX_ALL_IRQS)
  750.         {
  752.         /* EPIC IRQ set EPIC registers */
  754.         if (!sharing)
  755.             {
  756.             if ((int) vector < EPIC_VEC_IN_IRQ0)        /* EX type */
  757.                 {
  758.                 epicIntSourceSet ( epicGetVecRegAdrs ((int) vector),
  759.                                EPIC_EX_DFT_POLAR, EPIC_EX_DFT_SENSE,
  760.                                EPIC_PRIORITY_DEFAULT, (int) vector);
  761.                 }
  762.             else if ((int) vector < EPIC_VEC_GT_IRQ0)   /* IN type */
  763.                 {
  764.                 epicIntSourceSet ( epicGetVecRegAdrs ((int) vector),
  765.                                EPIC_IN_DFT_POLAR, 0x0,
  766.                                EPIC_PRIORITY_DEFAULT, (int) vector);
  767.                 }
  768.             else                                        /* other types */
  769.                 {
  770.                 epicIntSourceSet ( epicGetVecRegAdrs ((int) vector),
  771.                                0x0, 0x0,
  772.                                EPIC_PRIORITY_DEFAULT, (int) vector);
  773.                 }
  774.             }
  775.         }
  777.     intUnlock (intVal);
  779.     return (OK);
  780.     }
  782. /*******************************************************************************
  783. *
  784. * sysEpicIntHandlerExec  - execute the handlers for a given vector
  785. * 
  786. * This routine executes all the handlers chained to a given vector.
  787. * If a vector has no handlers attached to it, a logMsg is generated.
  788. *
  789. * NOMANUAL
  790. *
  791. * RETURNS: N/A
  792. *
  793. * ERRNO: N/A
  794. */
  796. LOCAL void sysEpicIntHandlerExec
  797.     (
  798.     int vector
  799.     )
  800.     {    
  801.     INT_HANDLER_DESC * pCurrHandler;
  803.     /*  call each respective interrupt handler */
  805.     if ((pCurrHandler = sysIntTbl [vector]) == NULL)
  806.         {
  807. logMsg ("uninitialized PIC interrupt vector 0x%xrn",
  808.                 vector, 0,0,0,0,0);
  809.         }
  810.     else
  811.         {
  814. /* call Each respective chained interrupt handler  */
  815. while (pCurrHandler != NULL)
  816.             {
  817.        (*pCurrHandler->vec) (pCurrHandler->arg);
  818.     pCurrHandler = pCurrHandler->next;
  819.             }
  821.         }
  822.     }
  824. /*******************************************************************************
  825. *
  826. * sysEpicIntHandler - handles the EPIC interrupts to the CPU
  827. *
  828. * This routine handles interrupts originating from the embedded interrupt
  829. * controller on the MPC8540 PowerPC processor.
  830. * This handler is entered from the 0x500 exception.
  831. *
  832. * This routine is entered with CPU external interrupts enables.
  833. *
  834. * Since the EPIC is the primary interrupt controller this driver
  835. * first initiates an Epic acknowledge call and reads the vector
  836. * put out by the EPIC. Subsequent vectors have to be obtained if
  837. * an external interrupt controller is connected to one of the
  838. * epic handlers. 
  839. *
  840. * This routine then processes the interrupt by calling all the interrupt
  841. * service routines chained to the vector.
  842. *
  843. * Finally, this routine re-arms the interrupt at the PIC by performing an 
  844. * PIC EOI for both the EPIC and the 8259s.
  845. *
  846. * RETURNS:  N/A
  847. *
  848. * ERRNO: N/A
  849. */
  851. LOCAL void  sysEpicIntHandler (void)
  852.     {
  853.     int epicIntVec;
  854.     int oldkey;
  856.     epicIntVec = epicIntAck (); /* clear int, return the vec for highest IRQ */
  858. #ifdef INCLUDE_WINDVIEW
  859.     WV_EVT_INT_ENT (epicIntVec);
  860. #endif 
  862.     /* loop till all interrupts are cleared */
  863.     while (epicIntVec != 0xffff)
  864.         {
  867.         /* Allow external interrupts to the CPU. */
  869. CPU_INT_UNLOCK (_PPC_MSR_EE);
  870.         sysEpicIntHandlerExec (epicIntVec);
  871. CPU_INT_LOCK (&oldkey);
  873.         /*
  874.          * Disable External Interrupts
  875.          * External Interrupts will be re-enabled in the kernel's wrapper
  876.          * of this Interrupt.
  877.          */
  880.         WRS_ASM ("sync");
  881.         epicEOI(); /* signal end of interrupt on EPIC */
  882.         WRS_ASM ("sync");
  884.         epicIntVec = epicIntAck ();
  887.         } /* while */
  889.     }
  891. #ifdef INCLUDE_EPIC_CRT_INTR
  892. /*
  893. *
  894. * epicCisr0Get - get critical interrupt summary
  895. *
  896. */
  898. UINT32 epicCisr0Get (void)
  899.     {
  900.     volatile unsigned long val;
  902.     val = *(volatile unsigned long *) (CCSBAR | 0x41330);
  903.     return val;
  904.     }
  906. /*
  907. *
  908. * epicCisr1Get - get critical interrupt summary
  909. *
  910. */
  911. UINT32 epicCisr1Get (void)
  912.     {
  913.     volatile unsigned long val;
  915.     val = *(volatile unsigned long *) (CCSBAR | 0x41340);
  916.     return val;
  917.     }
  919. /*
  920. *
  921. * sysEpicCrtIntHandler
  922. *
  923. */
  925. LOCAL void  sysEpicCrtIntHandler (void)
  926.     {
  927.     int oldkey;
  929.     volatile unsigned long extSumm;
  930.     volatile unsigned long intSumm;
  931.     int i;
  933.     while (((extSumm = (epicCisr0Get() & 0xfff)) != 0) ||
  934.            ((intSumm = epicCisr1Get()) != 0))
  935.         {
  936.         /* service external first */
  937.         for (i = 0; i < 12; i++)
  938.             {
  939.             if (((extSumm >> i) & 0x1) == 0x1)
  940.                 {
  941.                 /* CPU_INT_UNLOCK (_PPC_MSR_CE); */
  942.                 sysEpicIntHandlerExec (11 - i);
  943.                 /* CPU_INT_LOCK (&oldkey); */
  944.                 }
  945.             }
  947.         /* service internal */
  948.         for (i = 0; i < 32; i++)
  949.             {
  950.             if (((intSumm >> i) & 0x1) == 0x1)
  951.                 {
  952.                 /* CPU_INT_UNLOCK (_PPC_MSR_CE); */
  953.                 sysEpicIntHandlerExec (EPIC_VEC_IN_IRQ0 + 31 - i);
  954.                 /* CPU_INT_LOCK (&oldkey); */
  955.                 }
  956.             }
  958.         }
  959.     }
  960. #endif  /* INCLUDE_EPIC_CRT_INTR */
  962. /*******************************************************************************
  963. *
  964. * epicCurTaskPrioSet - set the priority of the current task.
  965. *
  966. * NOTES
  967. *
  968. * epicCurTaskPrioSet sets the priority of the Processor Current Task
  969. * Priority register to the value of the prioNum parameter.  This function
  970. * should be called after sysEpicInit() to lower the priority of the processor
  971. * current task. Note that valid priority values are 0 through 15 (15 being
  972. * the highest priority)
  973. *
  974. * NOMANUAL
  975. * 
  976. * RETURNS: previous priority of the task.
  977. *
  978. * ERRNO: N/A
  979. */
  981. int epicCurTaskPrioSet
  982.     (
  983.     int prioNum
  984.     )
  985.     {
  986.     ULONG oldPrio;
  988.     if ((prioNum < EPIC_PRIORITY_MIN) || (prioNum > EPIC_PRIORITY_MAX))
  989.         {
  990.         return ((int) EPIC_INV_PRIO_ERROR);
  991. }
  993.     oldPrio = sysEpicRegRead (EPIC_CTASK_PRI_REG);
  995.     sysEpicRegWrite (EPIC_CTASK_PRI_REG, prioNum);
  997.     return (oldPrio);
  998.     }
  1000. /*******************************************************************************
  1001. *
  1002. * epicIntEnable - enable an EPIC interrupt, given its IVPR
  1003. *
  1004. * This function clears the mask bit of an external, an internal or
  1005. * a Timer register to enable the interrupt.
  1006. *
  1007. * <srcAddr> is the address offset of the Vector Priority register  
  1008. *
  1009. * NOMANUAL
  1010. * 
  1011. * RETURNS: OK or an error code if the IVPR passed in was invalid.
  1012. *
  1013. * ERRNO: N/A
  1014. */
  1016. LOCAL int epicIntEnable
  1017.     (
  1018.     ULONG  srcAddr
  1019.     )
  1020.     {
  1021.     ULONG  srcVal;
  1022.     int  errCode;
  1023.   
  1024.     errCode = epicSrcAddrCheck (srcAddr);
  1026.     if (errCode == EPIC_INV_INTER_SOURCE)
  1027.         {
  1028.         return (errCode);
  1029.         }
  1031.     srcVal = sysEpicRegRead (srcAddr);
  1033.     switch (errCode)
  1034.         {
  1035.         case EPIC_EX_INTERRUPT:
  1036.             srcVal &= ~(EPIC_EIVPR_INTR_MSK);   /* clear the mask bit */
  1037.         break;
  1039.         case EPIC_IN_INTERRUPT:
  1040.             srcVal &= ~(EPIC_IIVPR_INTR_MSK);   /* clear the mask bit */
  1041.         break;
  1043.         case EPIC_GT_INTERRUPT:
  1044.             srcVal &= ~(EPIC_GTVPR_INTR_MSK);   /* clear the mask bit */
  1045.         break;
  1047.         case EPIC_MSG_INTERRUPT:
  1048.             srcVal &= ~(EPIC_MIVPR_INTR_MSK);   /* clear the mask bit */
  1049.         break;
  1051.         case EPIC_IPI_INTERRUPT:
  1052.             srcVal &= ~(EPIC_IPIVPR_INTR_MSK);  /* clear the mask bit */
  1053.         break;
  1055.         default:
  1056.             return (ERROR);
  1057.         }
  1059.     sysEpicRegWrite (srcAddr, srcVal);
  1061.     return OK;
  1063.     }
  1065. /*******************************************************************************
  1066. *
  1067. * epicIntDisable - disable an EPIC interrupt, given its IVPR
  1068. *
  1069. * This function sets the mask bit of an external, an internal,
  1070. * a timer, a message, or an IPI register to disable the interrupt.
  1071. * <srcAddr> is the address offset of the Vector Priority register.
  1072. *
  1073. * NOMANUAL
  1074. * 
  1075. * RETURNS: OK or an error code if the IVPR passed in was invalid.
  1076. *
  1077. * ERRNO: N/A
  1078. */
  1079.                
  1080. LOCAL int epicIntDisable
  1081.     (
  1082.     ULONG  srcAddr
  1083.     )
  1084.     {
  1085.     ULONG  srcVal;
  1086.     int  errCode;
  1087.   
  1088.     errCode = epicSrcAddrCheck (srcAddr);
  1090.     if (errCode == EPIC_INV_INTER_SOURCE)
  1091.         {
  1092.         return (errCode);
  1093.         }
  1095.     srcVal = sysEpicRegRead (srcAddr);
  1097.     switch (errCode)
  1098.         {
  1099.         case EPIC_EX_INTERRUPT:
  1100.             srcVal |= EPIC_EIVPR_INTR_MSK; /* set the mask bit */
  1101.         break;
  1103.         case EPIC_IN_INTERRUPT:
  1104.             srcVal |= EPIC_IIVPR_INTR_MSK; /* set the mask bit */
  1105.         break;
  1107.         case EPIC_GT_INTERRUPT:
  1108.             srcVal |= EPIC_GTVPR_INTR_MSK; /* set the mask bit */
  1109.         break;
  1111.         case EPIC_MSG_INTERRUPT:
  1112.             srcVal |= EPIC_MIVPR_INTR_MSK; /* set the mask bit */
  1113.         break;
  1115.         case EPIC_IPI_INTERRUPT:
  1116.             srcVal |= EPIC_IPIVPR_INTR_MSK; /* set the mask bit */
  1117.         break;
  1119.         default:
  1120.             return (ERROR);
  1121.         }
  1123.     sysEpicRegWrite (srcAddr, srcVal);
  1125.     return OK;
  1126.     }
  1128. #ifdef INCLUDE_EPIC_CRT_INTR
  1129. /*
  1130. *
  1131. */
  1132. LOCAL int epicCrtIntSet
  1133.     (
  1134.     ULONG  srcAddr
  1135.     )
  1136.     {
  1137.     ULONG  srcVal;
  1138.     int  errCode = EPIC_EX_INTERRUPT;    /* same bits for all types */
  1139.   
  1140.     srcVal = sysEpicRegRead (srcAddr);
  1142.     switch (errCode)
  1143.         {
  1144.         case EPIC_EX_INTERRUPT:
  1145.             srcVal |= EPIC_EIDR_CRIT_INT;       /* set critical bit */
  1146.         break;
  1148.         case EPIC_IN_INTERRUPT:
  1149.             srcVal |= EPIC_IIDR_CRIT_INT;       /* set critical bit */
  1150.         break;
  1152.         case EPIC_GT_INTERRUPT:
  1153.             return (ERROR);                     /* not supported */
  1154.         break;
  1156.         case EPIC_MSG_INTERRUPT:
  1157.             srcVal |= EPIC_MIDR_CRIT_INT;       /* set critical bit */
  1158.         break;
  1160.         case EPIC_IPI_INTERRUPT:
  1161.             return (ERROR);                     /* not supported */
  1162.         break;
  1164.         default:
  1165.             return (ERROR);
  1166.         }
  1168.     sysEpicRegWrite (srcAddr, srcVal);
  1170.     return OK;
  1171.     }
  1173. /*
  1174. *
  1175. */
  1176. LOCAL int epicCrtIntUnset
  1177.     (
  1178.     ULONG  srcAddr
  1179.     )
  1180.     {
  1181.     ULONG  srcVal;
  1182.     int  errCode = EPIC_EX_INTERRUPT;    /* same bits for all types */
  1183.   
  1184.     srcVal = sysEpicRegRead (srcAddr);
  1186.     switch (errCode)
  1187.         {
  1188.         case EPIC_EX_INTERRUPT:
  1189.             srcVal &= ~(EPIC_EIDR_CRIT_INT);    /* set critical bit */
  1190.         break;
  1192.         case EPIC_IN_INTERRUPT:
  1193.             srcVal &= ~(EPIC_IIDR_CRIT_INT);    /* set critical bit */
  1194.         break;
  1196.         case EPIC_GT_INTERRUPT:
  1197.             return (ERROR);                     /* not supported */
  1198.         break;
  1200.         case EPIC_MSG_INTERRUPT:
  1201.             srcVal &= ~(EPIC_MIDR_CRIT_INT);    /* set critical bit */
  1202.         break;
  1204.         case EPIC_IPI_INTERRUPT:
  1205.             return (ERROR);                     /* not supported */
  1206.         break;
  1208.         default:
  1209.             return (ERROR);
  1210.         }
  1212.     sysEpicRegWrite (srcAddr, srcVal);
  1214.     return OK;
  1215.     }
  1217. /*
  1218. *
  1219. */
  1220. LOCAL int epicCrtIntGet
  1221.     (
  1222.     ULONG  srcAddr
  1223.     )
  1224.     {
  1225.     ULONG  srcVal;
  1226.     int  errCode = EPIC_EX_INTERRUPT;    /* same bits for all types */
  1227.   
  1228.     srcVal = sysEpicRegRead (srcAddr);
  1230.     switch (errCode)
  1231.         {
  1232.         case EPIC_EX_INTERRUPT:
  1233.             srcVal = (srcVal >> 30) & 1;
  1234.         break;
  1235.         }
  1237.     return srcVal;
  1238. }
  1240. /*
  1241. *
  1242. */
  1243. int  sysEpicCrtIntSet
  1244.     (
  1245.     int vector
  1246.     )
  1247.     {
  1249.     if ((vector < 0)  || (vector >= EPIC_MAX_ALL_IRQS))
  1250.         return (ERROR);
  1252.     /* enable critical bit on EPIC */
  1254.     return epicCrtIntSet ( epicGetDestRegAdrs (vector) );
  1255.     }
  1257. /*
  1258. *
  1259. */
  1260. int  sysEpicCrtIntUnset
  1261.     (
  1262.     int vector
  1263.     )
  1264.     {
  1266.     if ((vector < 0)  || (vector >= EPIC_MAX_ALL_IRQS))
  1267.         return (ERROR);
  1269.     /* disable critical bit on EPIC */
  1271.     return epicCrtIntUnset ( epicGetDestRegAdrs (vector) );
  1272.     }
  1274. /*
  1275. *
  1276. */
  1277. int  sysEpicCrtIntGet
  1278.     (
  1279.     int vector
  1280.     )
  1281.     {
  1283.     if ((vector < 0)  || (vector >= EPIC_MAX_ALL_IRQS))
  1284.         return (ERROR);
  1286.     /* obtain critical bit on EPIC */
  1288.     return epicCrtIntGet ( epicGetDestRegAdrs (vector) );
  1289.     }
  1290. #endif  /* INCLUDE_EPIC_CRT_INTR */
  1292. /*******************************************************************************
  1293. *
  1294. * epicIntAck - read the IACK register and return vector
  1295. * 
  1296. * NOTES
  1297. *
  1298. * epicIntAck reads the Interrupt acknowledge register and return
  1299. * the vector number of the highest pending interrupt.
  1300. *
  1301. * NOMANUAL
  1302. * 
  1303. * RETURNS: the vector number of the highest priority pending interrupt.
  1304. *
  1305. * ERRNO: N/A
  1306. */
  1308. int epicIntAck(void)
  1309.     {
  1310.     int eumbVal;
  1312.     eumbVal = sysEpicRegRead (EPIC_INT_ACK_REG);
  1313.     WRS_ASM ("isync;sync");
  1314.     return eumbVal;
  1316.     }
  1318. /*******************************************************************************
  1319. *
  1320. * epic EOI 0 signal end of interrupt on the EPIC
  1321. *
  1322. * NOTES
  1323. *
  1324. * epicEOI writes 0x0 to the EOI register to signal end of interrupt.
  1325. * This function is usually called after an interrupt routine is served.
  1326. *
  1327. * NOMANUAL
  1328. * 
  1329. * RETURNS: N/A
  1330. *
  1331. * ERRNO: N/A
  1332. */
  1334. void epicEOI(void)
  1335.     {
  1336.     sysEpicRegWrite (EPIC_EOI_REG, 0x0);
  1337.     }
  1339. /*******************************************************************************
  1340. *
  1341. * epicGetVecRegAdrs - translate a vector to vector reg address
  1342. *
  1343. * This routine translates a vector to vector reg address.
  1344. *
  1345. * NOMANUAL
  1346. *
  1347. * RETURNS: vector register address of the corresponding vector type
  1348. */
  1350. ULONG epicGetVecRegAdrs
  1351.     (
  1352.     int vector
  1353.     )
  1354.     {
  1355.     if ((vector < EPIC_VEC_EXT_IRQ0) || (vector >= EPIC_VEC_CTRL_EXT))
  1356.         return ((ULONG) ERROR);
  1358.     if (vector < EPIC_VEC_IN_IRQ0)    /* type EXT */
  1359.         {
  1360.         return (EPIC_EX_VEC_REG (vector - EPIC_VEC_EXT_IRQ0));
  1361.         }
  1363.     if (vector < EPIC_VEC_GT_IRQ0)    /* type IN */
  1364.         {
  1365.         return (EPIC_IN_VEC_REG (vector - EPIC_VEC_IN_IRQ0));
  1366.         }
  1368.     if (vector < EPIC_VEC_MSG_IRQ0)    /* type GT */
  1369.         {
  1370.         return (EPIC_GT_VEC_REG (vector - EPIC_VEC_GT_IRQ0));
  1371.         }
  1373.     if (vector < EPIC_VEC_IPI_IRQ0)    /* type MSG */
  1374.         {
  1375.         return (EPIC_MSG_VEC_REG (vector - EPIC_VEC_MSG_IRQ0));
  1376.         }
  1378.     if (vector < EPIC_VEC_CTRL_EXT)    /* type IPI */
  1379.         {
  1380.         return (EPIC_IPI_VEC_REG (vector - EPIC_VEC_IPI_IRQ0));
  1381.         }
  1383.     /* should not reach here */
  1384.     return ((ULONG) ERROR);
  1385.     }
  1387. /*******************************************************************************
  1388. *
  1389. * epicGetDestRegAdrs - translate a vector to destination reg address
  1390. *
  1391. * This routine translates a vector to destination reg address
  1392. *
  1393. * NOMANUAL
  1394. *
  1395. * RETURNS: the destination register address of the corresponding vector type
  1396. *
  1397. * ERRNO: N/A
  1398. */
  1400. ULONG epicGetDestRegAdrs
  1401.     (
  1402.     int vector
  1403.     )
  1404.     {
  1405.     if ((vector < EPIC_VEC_EXT_IRQ0) || (vector >= EPIC_VEC_CTRL_EXT))
  1406.         return ((ULONG) ERROR);
  1408.     if (vector < EPIC_VEC_IN_IRQ0)    /* type EXT */
  1409.         {
  1410.         return (EPIC_EX_DEST_REG (vector - EPIC_VEC_EXT_IRQ0));
  1411.         }
  1413.     if (vector < EPIC_VEC_GT_IRQ0)    /* type IN */
  1414.         {
  1415.         return (EPIC_IN_DEST_REG (vector - EPIC_VEC_IN_IRQ0));
  1416.         }
  1418.     if (vector < EPIC_VEC_MSG_IRQ0)    /* type GT */
  1419.         {
  1420.         return ((ULONG) ERROR);
  1421.         }
  1423.     if (vector < EPIC_VEC_IPI_IRQ0)    /* type MSG */
  1424.         {
  1425.         return (EPIC_MSG_DEST_REG (vector - EPIC_VEC_MSG_IRQ0));
  1426.         }
  1428.     if (vector < EPIC_VEC_CTRL_EXT)    /* type IPI */
  1429.         {
  1430.         return ((ULONG) ERROR);
  1431.         }
  1433.     /* should not reach here */
  1434.     return ((ULONG) ERROR);
  1435.     }
  1437. /*******************************************************************************
  1438. *
  1439. * epicSrcAddrCheck - check source of the VPR address
  1440. *
  1441. * This routine checks if the VPR address passed in is external, internal, 
  1442. * timer, message, or IPI.
  1443. *
  1444. * NOMANUAL
  1445. * 
  1446. * RETURNS: EPIC_IN_INTERRUPT for internal interrupt sources, or
  1447. *          EPIC_EX_INTERRUPT for external ones, or
  1448. *          EPIC_GT_INTERRUPT for global timer ones, or
  1449. *          EPIC_MSG_INTERRUPT for message ones, or
  1450. *          EPIC_IPI_INTERRUPT for IPI ones, or
  1451. *          EPIC_INV_INTER_SOURCE if an invalid address was passed.
  1452. *
  1453. * ERRNO: N/A
  1454. */
  1456. LOCAL int epicSrcAddrCheck
  1457.     (
  1458.     ULONG srcAddr
  1459.     )
  1460.     {
  1461.     switch (srcAddr)
  1462.         {
  1463. case EPIC_EX_INT0_VEC_REG:
  1464. case EPIC_EX_INT1_VEC_REG:
  1465. case EPIC_EX_INT2_VEC_REG:
  1466. case EPIC_EX_INT3_VEC_REG:
  1467. case EPIC_EX_INT4_VEC_REG:
  1468. case EPIC_EX_INT5_VEC_REG:
  1469. case EPIC_EX_INT6_VEC_REG:
  1470. case EPIC_EX_INT7_VEC_REG:
  1471. case EPIC_EX_INT8_VEC_REG:
  1472. case EPIC_EX_INT9_VEC_REG:
  1473. case EPIC_EX_INT10_VEC_REG:
  1474. case EPIC_EX_INT11_VEC_REG:
  1475.             return (EPIC_EX_INTERRUPT);
  1476. break;
  1478. case EPIC_IN_INT0_VEC_REG:
  1479. case EPIC_IN_INT1_VEC_REG:
  1480. case EPIC_IN_INT2_VEC_REG:
  1481. case EPIC_IN_INT3_VEC_REG:
  1482. case EPIC_IN_INT4_VEC_REG:
  1483. case EPIC_IN_INT5_VEC_REG:
  1484. case EPIC_IN_INT6_VEC_REG:
  1485. case EPIC_IN_INT7_VEC_REG:
  1486. case EPIC_IN_INT8_VEC_REG:
  1487. case EPIC_IN_INT9_VEC_REG:
  1488. case EPIC_IN_INT10_VEC_REG:
  1489. case EPIC_IN_INT11_VEC_REG:
  1490. case EPIC_IN_INT12_VEC_REG:
  1491. case EPIC_IN_INT13_VEC_REG:
  1492. case EPIC_IN_INT14_VEC_REG:
  1493. case EPIC_IN_INT15_VEC_REG:
  1494. case EPIC_IN_INT16_VEC_REG:
  1495. case EPIC_IN_INT17_VEC_REG:
  1496. case EPIC_IN_INT18_VEC_REG:
  1497. case EPIC_IN_INT19_VEC_REG:
  1498. case EPIC_IN_INT20_VEC_REG:
  1499. case EPIC_IN_INT21_VEC_REG:
  1500. case EPIC_IN_INT22_VEC_REG:
  1501. case EPIC_IN_INT23_VEC_REG:
  1502. case EPIC_IN_INT24_VEC_REG:
  1503. case EPIC_IN_INT25_VEC_REG:
  1504. case EPIC_IN_INT26_VEC_REG:
  1505. case EPIC_IN_INT27_VEC_REG:
  1506. case EPIC_IN_INT28_VEC_REG:
  1507. case EPIC_IN_INT29_VEC_REG:
  1508. case EPIC_IN_INT30_VEC_REG:
  1509. case EPIC_IN_INT31_VEC_REG:
  1510. case EPIC_IN_INT32_VEC_REG:
  1511. case EPIC_IN_INT33_VEC_REG:
  1512. case EPIC_IN_INT34_VEC_REG:
  1513. case EPIC_IN_INT35_VEC_REG:
  1514. case EPIC_IN_INT36_VEC_REG:
  1515. case EPIC_IN_INT37_VEC_REG:
  1516. case EPIC_IN_INT38_VEC_REG:
  1517. case EPIC_IN_INT39_VEC_REG:
  1518. case EPIC_IN_INT40_VEC_REG:
  1519. case EPIC_IN_INT41_VEC_REG:
  1520. case EPIC_IN_INT42_VEC_REG:
  1521. case EPIC_IN_INT43_VEC_REG:
  1522. case EPIC_IN_INT44_VEC_REG:
  1523. case EPIC_IN_INT45_VEC_REG:
  1524. case EPIC_IN_INT46_VEC_REG:
  1525. case EPIC_IN_INT47_VEC_REG:
  1526.             return (EPIC_IN_INTERRUPT);
  1527. break;
  1529. case EPIC_TM0_VEC_REG:
  1530. case EPIC_TM1_VEC_REG:
  1531. case EPIC_TM2_VEC_REG:
  1532. case EPIC_TM3_VEC_REG:
  1533.             return (EPIC_GT_INTERRUPT);
  1534. break;
  1536. case EPIC_MSG_INT0_VEC_REG:
  1537. case EPIC_MSG_INT1_VEC_REG:
  1538. case EPIC_MSG_INT2_VEC_REG:
  1539. case EPIC_MSG_INT3_VEC_REG:
  1540.             return (EPIC_MSG_INTERRUPT);
  1541. break;
  1543. case EPIC_IPI_0_VEC_REG:
  1544. case EPIC_IPI_1_VEC_REG:
  1545. case EPIC_IPI_2_VEC_REG:
  1546. case EPIC_IPI_3_VEC_REG:
  1547.             return (EPIC_IPI_INTERRUPT);
  1548. break;
  1550.         default:
  1551.             return (EPIC_INV_INTER_SOURCE);
  1553.         }
  1554.     }
  1556. /*******************************************************************************
  1557. *
  1558. * epicIntSourceSet - set interrupt parameters for an interrupt register
  1559. *
  1560. * This function sets the interrupt parameters for:
  1561. *     External vector/priority register (EIVPR)
  1562. *     Internal vector/priority register (IIVPR)
  1563. *     Global Timer vector/priority register (GTVPR)
  1564. *     Message vector/priority register (MIVPR)
  1565. *     IPI vector/priority register (IPIVPR)
  1566. * The interrupt parameters can only be set when the current source is not
  1567. * in-request or in-service, which is determined by the Activity bit.  This
  1568. * routine reads the Activity bit; if the value of this bit is 1 (in-request
  1569. * or in-service), it returns error; otherwise, it sets the value of the
  1570. * parameters to the register offset defined in srcAddr.
  1571. *
  1572. * inputs:  srcAddr:   Address Offset of the source interrupt register.  This
  1573. *       routine assumes that the srcAddr passed in is an valid
  1574. *       Source Vector Priority address.
  1575. *          polarity: Use by external & internal interrupts only.
  1576. *                    1 -  Enable active high or positive edge
  1577. *                    0 -  Enable active low or negative edge
  1578. *          sense:    Use by external interrupts only.
  1579. *                    1 -  Enable level sensitive interrupts
  1580. *                    0 -  Enable edge sensitive interrupts
  1581. *          priority: valid number 0 to 15   
  1582. *          vector:   valid number 0 - 65535 (16 bits)
  1583. *
  1584. * Errors:  EPIC_INV_INTER_SOURCE Invalid Source Address,
  1585. *          EPIC_INTER_IN_SERVICE Interrupt currently in service
  1586. *          ERROR Unknown type
  1587. *
  1588. * NOMANUAL
  1589. * 
  1590. * RETURNS: OK or one of errors above
  1591. *
  1592. * ERRNO: N/A
  1593. */
  1595. STATUS epicIntSourceSet
  1596.     (
  1597.     ULONG  srcAddr,     
  1598.     int  polarity,
  1599.     int  sense,
  1600.     int  priority,
  1601.     int  vector
  1602.     )
  1603.     {
  1604.     ULONG  srcVal;
  1605.     ULONG errCode;
  1606.   
  1607.     errCode = epicSrcAddrCheck(srcAddr);
  1609.     if (errCode == EPIC_INV_INTER_SOURCE)
  1610.         {
  1611.         return (errCode);
  1612.         }
  1614.     srcVal = sysEpicRegRead(srcAddr);
  1616.     switch (errCode)
  1617.         {
  1618.         case EPIC_EX_INTERRUPT:
  1619.             if (srcVal & EPIC_EIVPR_INTR_ACTIVE)
  1620.                 {
  1621.                 return (EPIC_INTER_IN_SERVICE);
  1622.                 }
  1623.             /* mask off current settings */
  1624.             srcVal &= ~(EPIC_EIVPR_INTR_POLARITY |
  1625.                         EPIC_EIVPR_INTR_SENSE |
  1626.                         EPIC_EIVPR_PRIORITY_MSK  |
  1627.                         EPIC_EIVPR_VECTOR_MSK);
  1628.             /* set new values */
  1629.             srcVal |= (EPIC_EIVPR_POLARITY (polarity) |
  1630.                        EPIC_EIVPR_SENS (sense) |
  1631.                        EPIC_EIVPR_PRIORITY (priority) |
  1632.                        EPIC_EIVPR_VECTOR (vector));
  1633.         break;
  1635.         case EPIC_IN_INTERRUPT:
  1636.             if (srcVal & EPIC_IIVPR_INTR_ACTIVE)
  1637.                 {
  1638.                 return (EPIC_INTER_IN_SERVICE);
  1639.                 }
  1640.             /* mask off current settings */
  1641.             srcVal &= ~(EPIC_IIVPR_INTR_POLARITY |
  1642.                         EPIC_IIVPR_PRIORITY_MSK  |
  1643.                         EPIC_IIVPR_VECTOR_MSK);
  1644.             /* set new values */
  1645.             srcVal |= (EPIC_IIVPR_POLARITY (polarity) |
  1646.                        EPIC_IIVPR_PRIORITY (priority) |
  1647.                        EPIC_IIVPR_VECTOR (vector));
  1648.         break;
  1650.         case EPIC_GT_INTERRUPT:
  1651.             if (srcVal & EPIC_GTVPR_INTR_ACTIVE)
  1652.                 {
  1653.                 return (EPIC_INTER_IN_SERVICE);
  1654.                 }
  1655.             /* mask off current settings */
  1656.             srcVal &= ~(EPIC_GTVPR_PRIORITY_MSK  |
  1657.                         EPIC_GTVPR_VECTOR_MSK);
  1658.             /* set new values */
  1659.             srcVal |= (EPIC_GTVPR_PRIORITY (priority) |
  1660.                        EPIC_GTVPR_VECTOR (vector));
  1661.         break;
  1663.         case EPIC_MSG_INTERRUPT:
  1664.             if (srcVal & EPIC_MIVPR_INTR_ACTIVE)
  1665.                 {
  1666.                 return (EPIC_INTER_IN_SERVICE);
  1667.                 }
  1668.             /* mask off current settings */
  1669.             srcVal &= ~(EPIC_MIVPR_PRIORITY_MSK  |
  1670.                         EPIC_MIVPR_VECTOR_MSK);
  1671.             /* set new values */
  1672.             srcVal |= (EPIC_MIVPR_PRIORITY (priority) |
  1673.                        EPIC_MIVPR_VECTOR (vector));
  1674.         break;
  1676.         case EPIC_IPI_INTERRUPT:
  1677.             if (srcVal & EPIC_IPIVPR_INTR_ACTIVE)
  1678.                 {
  1679.                 return (EPIC_INTER_IN_SERVICE);
  1680.                 }
  1681.             /* mask off current settings */
  1682.             srcVal &= ~(EPIC_IPIVPR_PRIORITY_MSK  |
  1683.                         EPIC_IPIVPR_VECTOR_MSK);
  1684.             /* set new values */
  1685.             srcVal |= (EPIC_IPIVPR_PRIORITY (priority) |
  1686.                        EPIC_IPIVPR_VECTOR (vector));
  1687.         break;
  1689.         default:
  1690.             return (ERROR);
  1691.         }
  1693.     sysEpicRegWrite(srcAddr, srcVal);
  1695.     return (OK);
  1696.     }
  1699. /*******************************************************************************
  1700. *
  1701. * epicIntSourceGet - retrieve information of an EPIC source vector register.
  1702. *
  1703. * This function retrieves information of an epic source vector register.
  1704. * The information includes the Enable bit, the polarity, sense bits, the
  1705. * interrupt priority and interrupt vector number.
  1706. * Input:  srcAddr   - address of the source vector register
  1707. * Output: enable    - whether the interrupt is enabled
  1708. *          polarity - interrupt polarity (high or low)
  1709. *          sense    - interrupt sense (level or edge)
  1710. *          Priority - interrupt priority
  1711. *          Vector   - interrupt vector number
  1712. *
  1713. * NOMANUAL
  1714. * 
  1715. * RETURNS: OK or ERROR or EPIC_INV_INTER_SOURCE
  1716. *
  1717. * ERRNO: N/A
  1718. */
  1720. STATUS epicIntSourceGet
  1721.     (
  1722.     ULONG  srcAddr,
  1723.     int * pEnableMask,
  1724.     int * pPolarity,
  1725.     int * pSense,
  1726.     int * pPriority,
  1727.     int * pVector
  1728.     )
  1729.     {
  1730.     ULONG  srcVal;
  1731.     int  errCode;
  1732.   
  1733.     errCode = epicSrcAddrCheck (srcAddr);
  1735.     if (errCode == EPIC_INV_INTER_SOURCE)
  1736.         {
  1737.         return errCode;
  1738.         }
  1740.     srcVal = sysEpicRegRead(srcAddr);
  1741.     
  1742.     switch (errCode)
  1743.         {
  1744.         case EPIC_EX_INTERRUPT:
  1745.             *pEnableMask  = (srcVal & EPIC_EIVPR_INTR_MSK)      >> 31;
  1746.             *pPolarity    = (srcVal & EPIC_EIVPR_INTR_POLARITY) >> 23;
  1747.             *pSense       = (srcVal & EPIC_EIVPR_INTR_SENSE)    >> 22;
  1748.             *pPriority    = (srcVal & EPIC_EIVPR_PRIORITY_MSK)  >> 16;
  1749.             *pVector      = (srcVal & EPIC_EIVPR_VECTOR_MSK);
  1750.         break;
  1752.         case EPIC_IN_INTERRUPT:
  1753.             *pEnableMask  = (srcVal & EPIC_IIVPR_INTR_MSK)      >> 31;
  1754.             *pPolarity    = (srcVal & EPIC_IIVPR_INTR_POLARITY) >> 23;
  1755.             *pPriority    = (srcVal & EPIC_IIVPR_PRIORITY_MSK)  >> 16;
  1756.             *pVector      = (srcVal & EPIC_IIVPR_VECTOR_MSK);
  1757.         break;
  1759.         case EPIC_GT_INTERRUPT:
  1760.             *pEnableMask  = (srcVal & EPIC_GTVPR_INTR_MSK)      >> 31;
  1761.             *pPriority    = (srcVal & EPIC_GTVPR_PRIORITY_MSK)  >> 16;
  1762.             *pVector      = (srcVal & EPIC_GTVPR_VECTOR_MSK);
  1763.         break;
  1765.         case EPIC_MSG_INTERRUPT:
  1766.             *pEnableMask  = (srcVal & EPIC_MIVPR_INTR_MSK)      >> 31;
  1767.             *pPriority    = (srcVal & EPIC_MIVPR_PRIORITY_MSK)  >> 16;
  1768.             *pVector      = (srcVal & EPIC_MIVPR_VECTOR_MSK);
  1769.         break;
  1771.         case EPIC_IPI_INTERRUPT:
  1772.             *pEnableMask  = (srcVal & EPIC_IPIVPR_INTR_MSK)     >> 31;
  1773.             *pPriority    = (srcVal & EPIC_IPIVPR_PRIORITY_MSK) >> 16;
  1774.             *pVector      = (srcVal & EPIC_IPIVPR_VECTOR_MSK);
  1775.         break;
  1777.         default:
  1778.             return (ERROR);
  1779.         }
  1781.     return (OK);
  1782.     }
  1784. /*******************************************************************************
  1785. *
  1786. * sysEpicRegRead - read a register from the EPIC address space
  1787. *
  1788. * This function reads a register from the EPIC address space. The
  1789. * register number <regNum> is added to the offset of the EPIC base address
  1790. *
  1791. * NOMANUAL
  1792. *
  1793. * RETURNS:  the 32 bit little endian value of the register.
  1794. *
  1795. * ERRNO: N/A
  1796. */
  1798. UINT32 sysEpicRegRead
  1799.     (
  1800.     ULONG regNum
  1801.     )
  1802.     {
  1803.     UINT32 temp;
  1805.     WRS_ASM("isync;sync");
  1806.     temp = *(UINT32 *) ((UINT32)CCSBAR + (UINT32)regNum) ;
  1807.     return (temp);
  1808.     }
  1810. /*******************************************************************************
  1811. *
  1812. * sysEpicRegWrite -  write a register to the EPIC address space
  1813. *
  1814. * This function writes a register to the EPIC address space. The
  1815. * register number <regNum> is added to the offset of the EPIC base address
  1816. * and the resulting address is loaded with <regVal>
  1817. *
  1818. * NOMANUAL
  1819. *
  1820. * RETURNS: N/A
  1821. *
  1822. * ERRNO: N/A
  1823. */
  1825. void sysEpicRegWrite
  1826.     (
  1827.     ULONG regNum,
  1828.     UINT32 regVal
  1829.     )
  1830.     {
  1832.     *(UINT32 *) (CCSBAR + regNum) = regVal;
  1833.     WRS_ASM("eieio;sync");
  1834.     return ;
  1835.     }