logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

vxworks中断初始化以及挂接分析

 立志德美 2019-04-22

这篇blog主要分为三部分：

1，中断初始化

2，vxbus架构中断的挂接

3，非vxbus架构的中断的挂接

1，中断的初始化
函数调用：
usrInit->sysStart->palInit->palDescInit()

/*为了方便查看，这里对函数 进行了删减
*palDescInit()函数对默认的中断函数进行了初始化
*/

  1. void palDescInit (void)
  2.     {
  3.     int idx;
  4. #ifndef _WRS_MIPS_NONCOMPLIANT_CONFIG_REG
  5.     UINT32 config;
  6. #endif	/* _WRS_MIPS_NONCOMPLIANT_CONFIG_REG */
  8.     bzero((char *)&palDesc, sizeof(palDesc));
  10.     palDesc.coreNum = 0;
  11.     palDesc.version = "1.1";
  13.     /* Hopefully code further down will be able to refine these */
  14.     palDesc.iCache.present = FALSE;
  15.     palDesc.dCache.present = FALSE;
  16.     palDesc.l2Cache.present = FALSE;
  17.     palDesc.l3Cache.present = FALSE;
  18.     if (IS_KSEGM((UINT32) &palDescInit))
  19. 	{
  20. 	/* executing a mapped kernel */
  22. 	palDesc.tVec.vectorAddr = (VIRT_ADDR *)T_VEC;
  23. 	palDesc.tVec.excHandler = (VIRT_ADDR *)mmuMipsTlbVec;
  24. 	palDesc.tVec.excSize    = mmuMipsTlbVecSize;
  26. 	palDesc.xVec.vectorAddr = (VIRT_ADDR *)X_VEC;
  27. 	palDesc.xVec.excHandler = (VIRT_ADDR *)mmuMipsXtlbVec;
  28. 	palDesc.xVec.excSize    = (UINT)mmuMipsXtlbVecSize;
  30. 	palDesc.cVec.vectorAddr = (VIRT_ADDR *)C_VEC;
  31. 	palDesc.cVec.excHandler = (VIRT_ADDR*)excCacheVec;
  32. 	palDesc.cVec.excSize    = (UINT)excCacheVecSize;
  34. 	palDesc.eVec.vectorAddr = (VIRT_ADDR *)E_VEC;
  35. 	palDesc.eVec.excHandler = (VIRT_ADDR *)excNormVmVec;
  36. 	palDesc.eVec.excSize    = (UINT)excNormVmVecSize;
  37. 	}
  38.     /* Reasonable defaults */
  39.     palDesc.tlb.supportedPageSizes = MMU_PAGE_MASK_8K;
  40. palDesc.tlb.mmuCacheable=MMU_R4K_STATE_INVALID_STATE >> MMU_R4K_CACHE_START；
  41.     palDesc.tlb.mmuUncacheable = CFG_CCA_UNCACHED;
  42.     palDesc.tlb.mmuCacheCopyback = CFG_CCA_CACHEABLE;
  43.     palDesc.tlb.mmuCacheWritethrough = CFG_CCA_ALIAS_CACHEABLE;
  44.     palDesc.tlb.mmuCacheCoherency =  CFG_CCA_COHERENT;
  45.     palDesc.iCache.modes = CACHE_MODES_SUPPORTED;
  46.     palDesc.dCache.modes = CACHE_MODES_SUPPORTED;
  47. }
  49. //重要的结构体说一下
  51. #define	T_VEC		K0BASE			/* tlbmiss vector */
  52. #define	X_VEC		(K0BASE+0x80)		/* xtlbmiss vector */
  53. #define	C_VEC		(K1BASE+0x100)		/* cache exception vector */
  54. #define	E_VEC		(K0BASE+0x180)		/* exception vector */
  56. #define	R_VEC		(K1BASE+0x1fc00000)	/* reset vector */
  57. #define BEV_VEC		(K1BASE+0x1fc00380)	/* boot exception vector */
  59. typedef struct
  60.     {
  61.     char		*version;	/* PAL version string */
  62.     int			coreNum;	/* processor number */
  63.     MIPS_EXC_VECTOR	tVec;           /*tlbmiss中断*/
  64.     MIPS_EXC_VECTOR	xVec;		/*xtlbmiss中断*/
  65.     MIPS_EXC_VECTOR	cVec;		/*cache异常中断*/
  66.     MIPS_EXC_VECTOR	eVec;		/*异常中断，包括中断(根据exccode码判别)*/
  67.     MIPS_MMU_INFO	tlb;  		/**/
  68.     MIPS_CACHE_INFO	iCache;        /*指令cache相关*/
  69.     MIPS_CACHE_INFO	dCache;	       /*数据cache相关*/
  70.     MIPS_CACHE_INFO	l2Cache;       /*二级cache相关*/
  71.     MIPS_CACHE_INFO	l3Cache;       /*三级cache相关*/
  72.     int			mmuType;	/* CR bits 9:7 */
  73.     BOOL		hasCP2;
  74.     BOOL		hasWatch;
  75.     BOOL		hasFPU;
  76.     } MIPS_PAL_DESC;

默认中断函数的安装： 
  1. 函数调用：
  2. usrInit->excVecInit
  4. /*在这里会安装默认的中断处理函数*/
  5. STATUS excVecInit (void)
  6.     {
  7.     ULONG srValue;		/* status register placeholder */
  8. 	/* Load tlb and Xtlb vectors */
  9. 	vecInit (&palDesc.tVec);
  10. 	vecInit (&palDesc.xVec);
  12. 	/* Load cache exception vector */
  13. 	vecInit (&palDesc.cVec);
  15. 	/* Load normal/interrupt vector */
  16. 	vecInit (&palDesc.eVec);
  17.     srValue = intSRGet();
  18.     srValue &= ~SR_BEV;
  19.     intSRSet(srValue);
  21.     return (OK);
  22.     }
  24. LOCAL void vecInit
  25.     (
  26.     MIPS_EXC_VECTOR * vectorDesc
  27.     )
  28.     {
  29.     if (vectorDesc->excSize)
  30. 	{
  31. 	/*把函数拷贝到设置的地址处*/
  32. 	bcopy ((const char *) vectorDesc->excHandler,
  33. 	       (char *) vectorDesc->vectorAddr, vectorDesc->excSize);
  34. 	 /*刷cache操作*/
  35. 	CACHE_TEXT_UPDATE (vectorDesc->vectorAddr, vectorDesc->excSize);
  36. 	}
  37.     }
  38. 到这里系统默认的中断处理函数就初始化完成。

这里找一个具体的中断控制器的初始化进行说明。(这是一个抽象出来的中断控制器，至于什么是抽象，也就是没有一个具体的物理硬件设备对应这个控制器，这只是一个软件层面的简化，这样对于中断的处理就更明显，直接。)

  1. 函数调用关系：
  2. usrInit->sysHwInit->vxbMipsLsnIntCtlrRegister
  3. 当这个控制其注册之后：
  4. vxbMipsLsnIntCtlrRegister->vxbDevRegister->vxbNewDriver->vxbDevInitRun

  1. /*vxbDevInitRun函数会调用设备对应的初始化函数对设备进行初始化*/
  2. LOCAL void vxbDevInitRun
  3.     (
  4.     VXB_DEVICE_ID devID,
  5.     struct vxbDevRegInfo * pDrv
  6.     )
  7.     {
  8.     /* first pass */
  9.     if (!(devID->flags & VXB_INST_INIT_DONE))
  10.         {
  11.         if ( pDrv->pDrvBusFuncs->devInstanceInit != NULL )
  12. 	    (*(pDrv->pDrvBusFuncs->devInstanceInit))(devID);
  13.         devID->flags |= VXB_INST_INIT_DONE;
  14.         }
  15.     /* second pass */
  17.     if (vxbInitPhase >= 2 && !(devID->flags & VXB_INST_INIT2_DONE))
  18.         {
  19.         if ( pDrv->pDrvBusFuncs->devInstanceInit2 != NULL )
  20. 	    (*(pDrv->pDrvBusFuncs->devInstanceInit2))(devID);
  21.         devID->flags |= VXB_INST_INIT2_DONE;
  22.         }
  23.     /* third pass */
  25.     if (vxbInitPhase >= 3 && !(devID->flags & VXB_INST_CONNECT_DONE))
  26.         {
  27.         if ( pDrv->pDrvBusFuncs->devInstanceConnect != NULL )
  28. 	    (*(pDrv->pDrvBusFuncs->devInstanceConnect))(devID);
  29.         devID->flags |= VXB_INST_CONNECT_DONE;
  30.         }
  31.     }

这里的pDrv->pDrvBusFuncs->devInstanceInit函数对应控制器的lsnIntCtlrInstInit函数，在lsnIntCtlrInstInit函数中调用了vxbMipsLsnIntCtlrInit对中断进行初始化。
  1. LOCAL VOID vxbMipsLsnIntCtlrInit
  2.     (
  3.     VXB_DEVICE_ID       pInst
  4.     )
  5.     {
  6.     HCF_DEVICE *pHcf = NULL;
  7.     BOOL icw4Needed = FALSE;
  8.     pVXB_LSN_INT_DRV_CTRL pDrvCtrl = pInst->pDrvCtrl;
  9. /*这里注意intCtlrHwConfGet，这是真正具体的初始化函数*/
  10.     intCtlrHwConfGet(pInst, pHcf, &(pDrvCtrl->isrHandle));
  11.     Loongson2H_interrupt_init();
  12. 	return;
  13.     }

intCtlrHwConfGet这个函数比较长，删减以下，可以看出来这个函数所作的工作就是从hwconf.c中得到设备对应的中断信息，并对每一个对应的引脚初始化为一个具体的结构体，结构体中包含的成员可以看一看。
  1. STATUS intCtlrHwConfGet
  2.     (
  3.     VXB_DEVICE_ID               pInst,
  4.     HCF_DEVICE *                pHcf,
  5.     struct intCtlrHwConf *      pEntries
  6.     )
  7.     {
  8.     struct intrCtlrInputs *     pCtlrInputs;  /*中断控制引脚*/
  9.     struct intrCtlrXBar *       pXbar;	      /*xbar路由*/
  10.     struct intrCtlrCpu *        pCpuTable;    /*对应那个cpu*/
  11.     struct intrCtlrPriority *   pPrioTable;   /*优先级*/
  12.     struct intrCtlrTrigger *    pTrigTable;   /*引发方式,上升沿,高低电平,下降沿*/
  13.     int                         tableSize;    /*控制引脚数组的大小*/	 
  14.     int                         i;
  15.     STATUS                      stat;
  16.     void *                      pValue;
  17.     void **                     ppValue;
  19.     /* save intCtlr ID */
  20.     pEntries->ctlrDev = pInst;
  21.     ppValue = &pValue;
  22. /*获取中断控制引脚组成的数组*/
  23.     stat = devResourceGet(pHcf, "input", HCF_RES_ADDR, ppValue);
  24.     pCtlrInputs = (struct intrCtlrInputs *)pValue;
  25.     if ( stat == OK )
  26.         {
  27. 	/*获取中断控制引脚数组的大小*/
  28.         stat = devResourceGet(pHcf, "inputTableSize", HCF_RES_INT, ppValue);
  29.         tableSize = (UINT32)pValue;
  31.         /*遍历表中的每个元素，并为每一个对应的引脚创建相应的结构体*/
  32.         for ( i = 0 ; i < tableSize ; i++ )
  33.             {
  34. 	    /*为引脚创建一个结构体*/
  35.             stat = intCtlrTableCreate(pEntries, pCtlrInputs->inputPin);
  37.             /*为创建的结构体中的元素进行赋值操作，包括引脚号(硬件上连接的引脚号)，驱动名字，drvunit以及drvIndex */
  38.    intCtlrTableUserSet(pEntries, pCtlrInputs->inputPin, pCtlrInputs->drvName,pCtlrInputs->drvUnit, pCtlrInputs->drvIndex);
  39.             pCtlrInputs++;
  40.             }
  41.         }
  43. /*获取优先级对应的数组*/
  44.     stat = devResourceGet(pHcf, "priority", HCF_RES_ADDR, ppValue);
  45.     pPrioTable = (struct intrCtlrPriority *)pValue;
  46.     if ( stat == OK )
  47.         {
  48. 	/*获取优先级表的大小*/
  49.       stat = devResourceGet(pHcf, "priorityTableSize", HCF_RES_INT, ppValue);
  50.         tableSize = (UINT32)pValue;
  51. 	/*遍历表中所有的元素，把值填入到对应的引脚结构体中*/
  52.         for ( i = 0 ; i < tableSize ; i++ )
  53.             {
  54.             /*再次a创建引脚结构体，防止没有创建 */
  55.             stat = intCtlrTableCreate(pEntries, pPrioTable->inputPin);
  56.             /*为结构体填入优先级 */
  57.             intCtlrTablePrioSet(pEntries, pPrioTable->inputPin,pPrioTable->priority);
  58.             pPrioTable++;
  59.             }
  60.         }
  61. /*下面操作基本都是类似的，获取对应的中断信息，并进行遍历填入到引脚结构体中*/
  62. /*获取引脚出发的方式*/
  63.     stat = devResourceGet(pHcf, "trigger", HCF_RES_ADDR, ppValue);
  64.     pTrigTable = (struct intrCtlrTrigger *)pValue;
  65.     if ( stat == OK )
  66.         {
  67.        stat = devResourceGet(pHcf, "triggerTableSize", HCF_RES_INT, ppValue);
  68.         tableSize = (UINT32)pValue;
  70.         for ( i = 0 ; i < tableSize ; i++ )
  71.             {
  72.             /* ensure pin record exists */
  74.             stat = intCtlrTableCreate(pEntries, pTrigTable->inputPin);
  75.             /* fill in trigger */
  77.             intCtlrTableTrigSet(pEntries, pTrigTable->inputPin, pTrigTable->trigger);
  78.             pTrigTable++;
  79.             }
  80.         }
  82. /*获取crossbar路由表*/
  83.     stat = devResourceGet(pHcf, "crossBar", HCF_RES_ADDR, ppValue);
  84.     pXbar = (struct intrCtlrXBar *)pValue;
  85.     if ( stat == OK )
  86.         {
  87.         stat = devResourceGet(pHcf, "crossBarTableSize", HCF_RES_INT, ppValue);
  88.         tableSize = (UINT32)pValue;
  89.         for ( i = 0 ; i < tableSize ; i++ )
  90.             {
  91.             /* ensure pin record exists */
  92.             stat = intCtlrTableCreate(pEntries, pXbar->inputPin);
  94.             intCtlrTableOutputSet(pEntries, pXbar->inputPin, pXbar->outputPin);
  95.             pXbar++;
  96.             }
  97.         }
  100.     stat = devResourceGet(pHcf, "cpuRoute", HCF_RES_ADDR, ppValue);
  101.     pCpuTable = (struct intrCtlrCpu *)pValue;
  103. #ifdef _WRS_CONFIG_SMP
  104.     if ( stat == OK )
  105.         {
  106.         stat = devResourceGet(pHcf, "cpuRouteTableSize", HCF_RES_INT, ppValue);
  107.         tableSize = (UINT32)pValue;
  108.         /* iterate through table */
  110.         for ( i = 0 ; i < tableSize ; i++ )
  111.             {
  112.             /* ensure pin record exists */
  113.             stat = intCtlrTableCreate(pEntries, pCpuTable->inputPin);
  115.             /* set destination CPU for this input pin  */
  117.             if (stat == OK)
  118.                 intCtlrTableCpuSet (pEntries, pCpuTable->inputPin,
  119.                                     pCpuTable->cpuNum);
  120.             pCpuTable++;
  121.             }
  122.         }
  123. #endif /* _WRS_CONFIG_SMP */
  124.     return(OK);
  125.     }


  1. /*创建中断表*/
  2. STATUS intCtlrTableCreate
  3.     (
  4.     struct intCtlrHwConf *	pInputs,
  5.     int				inputPin
  6.     )
  7.     {
  8.     int	  tblIndx = VXB_INTCTLRLIB_TBL_IDX(pInputs,inputPin);
  9.     int	  startPin = inputPin - (inputPin % VXB_INTCTLRLIB_LOWLVL_SIZE);
  10.     int	  i;
  12.     if ( pInputs->pTop == NULL )
  13. 	{
  14. 	/*分配一个结构体vxbIntCtlrInpTop*/
  15. 	pInputs->pTop = (struct vxbIntCtlrInpTop *)
  16. 			hwMemAlloc(sizeof(struct vxbIntCtlrInpTop));
  17.         }
  19.     if ( pInputs->pTop->tbl[tblIndx] == NULL )
  20. 	{
  21. 	/*分配结构体vxbIntCtlrInput*/
  22.         pInputs->pTop->tbl[tblIndx] = (struct vxbIntCtlrInput *)
  23. 			hwMemAlloc(sizeof(struct vxbIntCtlrInput) +
  24. 				   VXB_INTCTLRLIB_MIN_CACHE_LINE_SIZE);
  25. 	/*进行对齐操作*/
  26. 	pInputs->pTop->tbl[tblIndx] = (struct vxbIntCtlrInput *)
  27. 			ROUND_UP(pInputs->pTop->tbl[tblIndx],
  28. 				 VXB_INTCTLRLIB_MIN_CACHE_LINE_SIZE);
  29. 	/*赋值为0*/
  30. 	memset(pInputs->pTop->tbl[tblIndx],0,sizeof(struct vxbIntCtlrInput));
  32. 	/*为每一个引脚结构体中的中断函数以及中断函数参数赋一个系统默认的值 */
  33. 	for ( i = 0 ; i < VXB_INTCTLRLIB_NUM_PINS(pInputs) ; i++ )
  34. 	    {
  35. 	    pInputs->pTop->tbl[tblIndx]->pins[i].isr = intCtlrStrayISR;
  36. 	    pInputs->pTop->tbl[tblIndx]->pins[i].pArg = pInputs;
  37. 	    pInputs->pTop->tbl[tblIndx]->pins[i].pinFlags = startPin + i;
  38. 	    }
  39. 	}
  40.     return(OK);
  41.     }

  1. 对应引脚重要的结构体：
  3. struct intCtlrHwConf
  4.     {
  5.     VXB_DEVICE_ID	  ctlrDev;	  /* VXB_DEVICE_ID of int ctlr */
  6.     struct vxbIntCtlrInpTop * pTop;       /* top-level table of entries */
  7.     struct vxbLock         vxbIntCtlrLibLock;
  8.     };
  10. struct vxbIntCtlrInpTop
  11.     {
  12.     struct vxbIntCtlrInpTop * pNext;          /* not implemented */
  13.     struct vxbIntCtlrInput *  tbl[VXB_INTCTLRLIB_TOPLVL_SIZE];
  14.     UINT32                    reserved;
  15.     };
  16. #define VXB_INTCTLRLIB_TOPLVL_SIZE    496
  18. struct vxbIntCtlrInput
  19.     {
  20.     struct vxbIntCtlrPin      pins[VXB_INTCTLRLIB_LOWLVL_SIZE];
  21.     };
  22. /*最后的运算就是 2^x ,这里的定义也就是8*/
  23. #define VXB_INTCTLRLIB_LOWLVL_SIZE_POW 3 
  24. #define VXB_INTCTLRLIB_LOWLVL_SIZE   ( 1<< VXB_INTCTLRLIB_LOWLVL_SIZE_POW)
  26. struct vxbIntCtlrPin
  27.     {
  28.     struct intCtlrMoreDrvName * pMoreNames;
  29.     char *                      drvName;
  30.     int                         drvUnit;
  31.     int                         intIndex;
  33.     void                        (*isr)(void * pArg, int inputPin);
  34.     void *                      pArg;
  35.     int                         pinFlags;
  36.     UINT32                      pinPriority;
  37.     UINT32                      pinOutput;
  38.     UINT32                      pinCpu;
  39.     int				reserved [2];
  40.     };
这里就相当于创建了一个两级表，第一级是496的大小，第二级分别对应于第一级的每一个元素，大小为8，到这里中断的创建以及初始化就完成了。


2，中断的挂接
vxWorks中的vxbus架构初始化分为三个阶段，第一第二阶段一般都是对设备进行初始化，到第三阶段一般是中断的挂接和使能。这里举例说明的这个有点特殊，这是在第二阶段进行的中断挂接和使能，也从另一面说名代码没有特定的规定，都是为了方便


  1. 函数调用关系：
  2. usrRoot->sysClkInit->sysClkConnect->sysHwInit2->vxbDevInit->vxbDevInitInternal->vxbDevIterate->vxbDevInit2Helper->

  1. LOCAL STATUS vxbDevInit2Helper
  2.     (
  3.     struct vxbDev * pInst,
  4.     void * pArg
  5.     )
  6.     {
  7.     if ( pInst->pDriver->pDrvBusFuncs->devInstanceInit2 == NULL )
  8.         return(OK);
  9. 	/*这里调用第二阶段的初始化函数。*/
  10.     (*pInst->pDriver->pDrvBusFuncs->devInstanceInit2)(pInst);
  12.     pInst->flags |= VXB_INST_INIT2_DONE;
  14.     return(OK);
  15.     }
  16. 这里调用的第二阶段初始化函数对应的函数是：
  17. LOCAL VOID lsnIntCtlrInstInit2
  18.     (
  19.     VXB_DEVICE_ID       pInst
  20.     )
  21.     {
  22.      vxbIntConnect(pInst, 0, vxbMipsLsnIntCtrlIsr, (void*)pInst);
  23.     vxbIntEnable(pInst, 0, vxbMipsLsnIntCtrlIsr, (void*)pInst);
  24.     return;
  25.     }
  26. /*可以看出这里所作的工作就只有挂接中断和使能*/
  1. 这里中断挂接函数的函数调用关系：
  2. vxbIntConnect->vxbDevIterate->vxbIntCtlrMatch->vxbIntCtlrConnect

直接看函数：熟悉流程即可：

  1. STATUS vxbIntConnect
  2.     (
  3.     struct vxbDev * pDev,       /* Device Information */
  4.     int             index,      /* index of interrupt vector */
  5.     VOIDFUNCPTR     pIsr,       /* ISR */
  6.     void *          pArg        /* parameter */
  7.     )
  8.     {
  9.     VXB_ACCESS_INTERRUPT_INFO   accessIntrInfo;
  10.     struct vxbintCtlrMgmt info;
  12.     VXB_ASSERT(pDev!=NULL, ERROR)
  14.     info.found = FALSE;
  15.     info.pIntCtlr = NULL;
  16.     info.inputPin = 0;
  17.     info.pDev = pDev;
  18.     info.index = index;
  19.     info.pIsr = pIsr;
  20.     info.pArg = pArg;
  21.     /*这里一次把所有实例化的设备和要注册的info进行匹配*/
  22.     vxbDevIterate(vxbIntCtlrMatch, &info, VXB_ITERATE_INSTANCES);
  24.     if ( info.found == TRUE )
  25.         return(OK);
  26.     return (vxbDevControl (pDev, (pVXB_DEVCTL_HDR)&accessIntrInfo));
  27.     }


  1. LOCAL STATUS vxbIntCtlrMatch
  2.     (
  3.     struct vxbDev * pInst,
  4.     void * pArg
  5.     )
  6.     {
  7.     struct vxbintCtlrMgmt * pInfo = (struct vxbintCtlrMgmt *)pArg;
  8.     FUNCPTR   func;
  9.     STATUS    stat;
  10.     struct plbIntrEntry * pIntrEntry;
  11.     int			inputPin;
  12.     struct pIntCtlrTable * pICTab;
  13.     struct plbIntCtlrTable * pICTab2;
  14.     int		x;
  15.     int		y;
  16.     struct plbIntCtlrEntry * pEnt;
  17.     /*在这里会调用匹配到的设备的中断挂接函数，换句话说对不同的中断控制器上的中断挂接会调用对应的中断控制器的额挂接函数*/
  18.     func = vxbDevMethodGet(pInst, DEVMETHOD_CALL(vxbIntCtlrConnect));
  19.     stat = (*func)(pInst, pInfo->pDev, pInfo->index, pInfo->pIsr, pInfo->pArg, &inputPin);
  21.     if ( stat != OK )
  22.       return(OK);
  24.     pInfo->found = TRUE;
  26.     return(OK);
  27.     }

  1. 这里对应的中断挂接函数为：
  2. LOCAL STATUS vxbMipsLsnIntCtlrDevIsrConnect
  3.     (
  4.     VXB_DEVICE_ID	pIntCtlr,
  5.     VXB_DEVICE_ID	pDev,
  6.     int			indx,
  7.     void		(*pIsr)(void * pArg),
  8.     void              *	pArg,
  9.     int               *	pInputPin
  10.     )
  11.     {
  12.     pVXB_LSN_INT_DRV_CTRL pDrvCtrl = pIntCtlr->pDrvCtrl;
  13.     int                 inputPin = ERROR;
  14.     struct intCtlrHwConf * pIsrHandle = NULL;
  16.     inputPin = intCtlrPinFind (pDev, indx, pIntCtlr, &pDrvCtrl->isrHandle);
  18.     pIsrHandle = &(pDrvCtrl->isrHandle);
  20.     /*在这里调用intCtlrISRAdd函数，这个函数会真正的挂接用户的中断函数*/
  21.     if (intCtlrISRAdd(pIsrHandle, inputPin, pIsr, pArg) == ERROR)
  22.         return ERROR;
  24.     *pInputPin = inputPin;
  25.     return OK;
  26.     }


  1. STATUS intCtlrISRAdd
  2.     (
  3.     struct intCtlrHwConf *	pEntries,
  4.     int				inputPin,
  5.     void 			(*isr),
  6.     void *			pArg
  7.     )
  8.     {
  9.     struct intCtlrISRChainEntry * pChain;
  10.     struct intCtlrISRChainEntry * pChain2;
  11.     void *			  installedIsr;
  13.     /*这里要确保中断表已经创建 */
  14.     intCtlrTableCreate(pEntries, inputPin);
  16.     /*这里创建两个结构体，并初始化为用户中断，用于挂接中断时使用*/
  17.     pChain = (struct intCtlrISRChainEntry *)hwMemAlloc(sizeof(*pChain));
  19.     pChain2 = (struct intCtlrISRChainEntry *)hwMemAlloc(sizeof(*pChain));
  21.     pChain->isr = isr;
  22.     pChain->pArg = pArg;
  24.     /*获取目前表中现在挂接的中断函数，如果是函数intCtlrStrayISR说明已经初始化为默认的中断函数，
  25. 只需要替换为用户的中断函数即可，如果为函数intCtlrChainISR，说明已经至少挂接了一个用户中断函数(多个中断函数可以挂接在一个中断引脚上)，
  26. 如果为空，说明没有进行过初始化，这时就使用pChain2保存要挂接的中断函数，并赋值为pChain，然后填写到对应引脚上*/
  27.      installedIsr = intCtlrTableIsrGet(pEntries, inputPin);
  28.     if ( installedIsr == (void *)intCtlrStrayISR )
  29. 	{
  30. 	intCtlrTableFill(pEntries, inputPin, pChain->isr, pChain->pArg);
  31. 	}
  32.     else if ( installedIsr == (void *)intCtlrChainISR )
  33.         {
  34. 	pChain->pNext = (struct intCtlrISRChainEntry *)intCtlrTableArgGet(pEntries, inputPin);
  35. 	intCtlrTableFill(pEntries, inputPin, intCtlrChainISR, pChain);
  36. 	}
  37.     else
  38.         {
  39. 	/* create chain, add original entry and the new one */
  41. 	pChain2->flags = intCtlrTableFlagsGet(pEntries, inputPin);
  43. 	pChain2->pArg = intCtlrTableArgGet(pEntries, inputPin);
  45. 	pChain2->isr = installedIsr;
  47. 	pChain->pNext = pChain2;
  48. 	pChain2->pNext = NULL;
  50. 	intCtlrTableFill(pEntries, inputPin, intCtlrChainISR, pChain);
  51. 	}
  52.     return(OK);
  53.     }
  1. struct intCtlrISRChainEntry
  2.     {
  3.     struct intCtlrISRChainEntry * pNext;
  4.     void			  (*isr)(void * pArg, int inputPin);
  5.     void *			  pArg;
  6.     UINT32			  flags;
  7.     };


呼～～，到这里中断的额挂接就完成了。当然了这只是vxWorks系统中属于vxbus架构的函数的挂接，但是这就包含了绝大部分的中断呢。

3，非vxbus中断的挂接
下面说一下不是vxbus结构的中断函数的挂接。
不是vxbus架构的中断函数使用intConnect函数进行挂接，废话少说，看函数：

  1. STATUS intConnect
  2.     (
  3.     VOIDFUNCPTR * vector,	/* interrupt vector to attach to     */
  4.     VOIDFUNCPTR   routine,	/* routine to be called              */
  5.     int           parameter	/* parameter to be passed to routine */
  6.     )
  7.     {
  8.     /*这里首先看到，进行了三次判断，分别代表的三种中断的挂接，是首先第一种_func_isrConnect，
  9.       这是isrobjectn中断的挂接，目前对于isrobject还没有深入分析过，不过这必须打开#INCLUDE_ISR_OBJECT宏定义才可以，
  10.       这里不运行；intArchConnect这个函数就是结构中断的额挂接，一个中断号挂接一个中断，当然了在这里执行不到；
  11.    _func_vxbIntConnect这个函数才是这次的重点，这个函数在vxbLegacyIntInit中被赋值，
  12.     _func_vxbIntConnect = vxbLegacyIntConnect，看一下这个初始化函数*/
  14.     if (_func_isrConnect != NULL)
  15. 	if (_func_isrConnect (vector, routine, parameter) == OK)
  16. 	    return (OK);
  19.     if (_func_vxbIntConnect != NULL)
  20.         if (_func_vxbIntConnect(vector, routine, parameter) == OK)
  21.             return (OK);
  23.     return (intArchConnect (vector, (VOIDFUNCPTR) routine, 
  24.                             (int) parameter));        
  25.     }

  1. void vxbLegacyIntInit()
  2.     {
  3.     VXB_DEVICE_ID devID;
  4.     struct plbIntrEntry *       pIntrInfo;
  6.     /*申请一个legacy设备(legacy在这里代表不是vxbus架构设备也可以说为遗留设备)*/
  7.     devID = vxbDevStructAlloc(WAIT_FOREVER);
  9.     /*初始化设备，主要是名字和总线号，用于之后匹配挂接于那个中断控制器*/
  10.     devID->pName = "legacy";
  11.     devID->pParentBus = pPlbDev->u.pSubordinateBus;
  12.     devID->busID = VXB_BUSID_PLB;
  13.     devID->pRegBase[0] = (void *)1;
  16.     pIntrInfo = (struct plbIntrEntry *)hwMemAlloc(sizeof(*pIntrInfo)); 
  18.     devID->pIntrInfo = pIntrInfo;
  20.     /*声明设备已经注册到系统中*/
  21.     if ( vxbDeviceAnnounce(devID) != OK )
  22. 	{
  23. 	vxbDevStructFree(devID);
  24.         return;
  25. 	}
  27.     vxbLegacyIntDevice = devID;
  28.     _func_vxbIntConnect = vxbLegacyIntConnect;
  29.     _func_vxbIntDisconnect = vxbLegacyIntDisconnect;
  30.     _func_vxbIntEnable = vxbLegacyIntEnable;
  31.     _func_vxbIntDisable = vxbLegacyIntDisable;
  32.     }

  1. LOCAL STATUS vxbLegacyIntConnect
  2.     (
  3.     VOIDFUNCPTR * vector,       /* interrupt vector to attach to     */
  4.     VOIDFUNCPTR   routine,      /* routine to be called              */
  5.     int           parameter     /* parameter to be passed to routine */
  6.     )
  7.     {
  8.     /*在这里调用vxbIntConnect函数把中断注册进vxbus架构的中断表中*/
  9.     if ((vxbIntConnect(vxbLegacyIntDevice,(int)vector,routine,
  10.            (void *)parameter)) != OK)
  11.         return ERROR;
  13.     return(vxbIntEnable(vxbLegacyIntDevice,(int)vector,routine,
  14.            (void *)parameter));
  15.     }

  1. 之后就和上面vxbus中断的挂接一样了：
  2. vxbIntConnect->vxbDevIterate->vxbIntCtlrMatch->vxbDevMethodGet->vxbIntCtlrConnect->vxbMipsLsnIntCtlrDevIsrConnect

OK...到这里非vxbus结构的中断挂接也完成了。

这里要说明一下：
func = vxbDevMethodGet(pInst, DEVMETHOD_CALL(vxbIntCtlrConnect));这个函数会调用所有注册进系统并实例化的设备对应的vxbIntCtlrConnect函数来进行挂接，但是这里还有一个函数，确保了中断函数会注册进对应的中断控制器中inputPin = intCtlrPinFind (pDev, indx, pIntCtlr, &pDrvCtrl->isrHandle)，这个intCtlrPinFind函数只有在对应中断控制器中才可以找到对应的引脚结构体。这也就保证了会注册到对应的引脚结构体中。

ok～～，分析就先到这里，如果有什么不对地方，请留言。。。

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 立志德美 > 《VxWorks》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多