wince 5.0 .2440 5.0BSP的中断过程

gw1428jk | 2009-02-05 16:46:40 阅读：16677

wince 5.0 .2440 5.0BSP的中断过程

转载请标明:作者wogoyixikexie@gliet.桂林电子科技大学一系科协，原文地址：http://www.cnblogs.com/wogoyixikexie/（或者我在CSDN的博客：http://blog.csdn.net/gooogleman

以前在CSDN写过一些wince5.0中断的文章，现在重新看看，发现以前的有些理解是错误的，想翻开来改改，可是郁闷的CSDN在前台没有返回后台的编辑功能，所以现在重新写一篇纠正一下。

首先描述wince5.0 （2440BSP）的中断流程

注册表等——》KernelIoControl（——》OEMIoControl——》OALIntrRequestIrqs ）把物理中断转换成系统中断——》InterruptInitialize调用OEMInterruptEnable使能中断并用中断绑定线程——》OEMInterruptHandler屏蔽中断——》执行线程——》InterruptDone——》调用OEMInterruptDone——》调用OALIntrDoneIrqs完成中断线程并重新使能中断

现在看来，5.0BSP和4.2BSP的中断并没有太大差别，一个是动态，一个是静态，OEMInterruptEnable，OEMInterruptHandler函数位置不一样而已——有空看看中断的汇编部分和PB帮助，那么一切都会明了。

File: oem.c

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

--  1 //
  2 // Copyright (c) Microsoft Corporation.  All rights reserved.
  3 //
  4 //
  5 // Use of this source code is subject to the terms of the Microsoft end-user
  6 // license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
  7 // If you did not accept the terms of the EULA, you are not authorized to use
  8 // this source code. For a copy of the EULA, please see the LICENSE.RTF on your
  9 // install media.
10 //
11 //------------------------------------------------------------------------------
12 //
13 //  File: oem.c
14 //
15 //  This file implements a standard implementation of OEMInterrupt functions
16 //  relating to enabling, disabling and finishing interrupts.
17 //
18 #include <windows.h>
19 #include <nkintr.h>
20 #include <oal.h>
21
22
23 //------------------------------------------------------------------------------
24 //
25 //  Function:  OEMInterruptEnable
26 //
27 //  This function enables the IRQ given its corresponding SysIntr value.
28 //  Function returns true if SysIntr is valid, else false.
29 //
30 BOOL OEMInterruptEnable(DWORD sysIntr, LPVOID pvData, DWORD cbData)
31 {
32     BOOL rc = FALSE;
33     const UINT32 *pIrqs;
34     UINT32 count;
35
36     OALMSG(OAL_INTR&&OAL_VERBOSE,
37         (L"+OEMInterruptEnable(%d, 0x%x, %d)\r\n", sysIntr, pvData, cbData
38     ));
39
40     // SYSINTR_VMINI & SYSINTR_TIMING are special cases
41     if (sysIntr == SYSINTR_VMINI || sysIntr == SYSINTR_TIMING) {
42         rc = TRUE;
43         goto cleanUp;
44     }
45
46     // Obtain the SYSINTR's underlying IRQ number
47     if (!OALIntrTranslateSysIntr(sysIntr, &count, &pIrqs)) {
48         // Indicate invalid SysIntr
49         OALMSG(OAL_ERROR, (
50             L"ERROR: OEMInterruptEnable: IRQs are undefined for SysIntr %d\r\n",
51             sysIntr
52         ));
53         goto cleanUp;
54     }
55
56     // Enable the interrupt
57     rc = OALIntrEnableIrqs(count, pIrqs);
58
59 cleanUp:
60     OALMSG(OAL_INTR&&OAL_VERBOSE, (L"-OEMInterruptEnable(rc = 1)\r\n"));
61     return rc;
62 }
63
64
65 //------------------------------------------------------------------------------
66 //
67 //  Function:  OEMInterruptDisable(DWORD sysIntr)
68 //
69 //  This function disables the IRQ given its corresponding SysIntr value.
70 //
71 //
72 VOID OEMInterruptDisable(DWORD sysIntr)
73 {
74     const UINT32 *pIrqs;
75     UINT32 count;
76
77     OALMSG(OAL_INTR&&OAL_VERBOSE, (L"+OEMInterruptDisable(%d)\r\n", sysIntr));
78
79     // Obtain the SYSINTR's underlying IRQ number
80     if (!OALIntrTranslateSysIntr(sysIntr, &count, &pIrqs)) {
81         // Indicate invalid SysIntr
82         OALMSG(OAL_ERROR, (
83             L"ERROR: OEMInterruptEnable: IRQs are undefined for SysIntr %d\r\n",
84             sysIntr
85         ));
86         goto cleanUp;
87     }
88
89     // Disable the interrupt
90     OALIntrDisableIrqs(count, pIrqs);
91
92 cleanUp:
93     // Indicate exit
94     OALMSG(OAL_INTR&&OAL_VERBOSE, (L"-OEMInterruptDisable\r\n"));
95 }
96
97
98 //------------------------------------------------------------------------------
99 //
100 //  Function: OEMInterruptDone
101 //
102 //  OEMInterruptDone is called by the kernel when a device driver
103 //  calls InterruptDone(). The system is not preemtible when this
104 //  function is called.
105 //
106 VOID OEMInterruptDone(DWORD sysIntr)
107 {
108     const UINT32 *pIrqs;
109     UINT32 count;
110
111     OALMSG(OAL_INTR&&OAL_VERBOSE, (L"+OEMInterruptDone(%d)\r\n", sysIntr));
112     if (OALIntrTranslateSysIntr(sysIntr, &count, &pIrqs)) {
113         OALIntrDoneIrqs(count, pIrqs);
114     }
115     OALMSG(OAL_INTR&&OAL_VERBOSE, (L"-OEMInterruptDone\r\n"));
116 }
117
118 //------------------------------------------------------------------------------
119

看OALIntrTranslateSysIntr，

OALIntrTranslateSysIntr

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-- 1 //------------------------------------------------------------------------------
2 //
3 //  Function:  OALIntrTranslateSysIntr
4 //
5 //  This function maps a SYSINTR to its corresponding IRQ. It is typically used
6 //  in OEMInterruptXXX to obtain IRQs for given SYSINTR.
7 //
8 BOOL OALIntrTranslateSysIntr(
9     UINT32 sysIntr, UINT32 *pCount, const UINT32 **ppIrqs
10 ) {
11     BOOL rc;
12
13     OALMSG(OAL_INTR&&OAL_VERBOSE, (L"+OALTranslateSysIntr(%d)\r\n", sysIntr));
14
15     // Valid SYSINTR?
16     if (sysIntr >= SYSINTR_MAXIMUM) {
17         rc = FALSE;
18         goto cleanUp;
19     }
20     *pCount = 1;
21     *ppIrqs = &g_oalSysIntr2Irq[sysIntr];
22     rc = TRUE;
23
24 cleanUp:
25     OALMSG(OAL_INTR&&OAL_VERBOSE, (L"-OALTranslateSysIntr(rc = %d)\r\n", rc));
26     return rc;
27 }
28

从上面的代码可以知道，以前说这个系统中断数目限制是从哪里来的SYSINTR_MAXIMUM是系统限定了。

不知道系统为什么要做这个限制，我想如果想改动，也是可行的。不过我觉得有点奇怪，这个中断相关的g_oalIrq2SysIntr是怎么回事呢

static UINT32 g_oalSysIntr2Irq[SYSINTR_MAXIMUM];
static UINT32 g_oalIrq2SysIntr[OAL_INTR_IRQ_MAXIMUM];

我原以为是个全局数组，现在看来，还是另有玄机。现在看看g_oalIrq2SysIntr这些到底在哪里被修改过了，就知道这是怎么来的了

Code

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

--  1 //------------------------------------------------------------------------------
  2 //  刚开始的时候，g_oalSysIntr2Irq和g_oalIrq2SysIntr都是初始化为未定义的
  3 //  Function:  OALIntrMapInit
  4 //
  5 //  This function must be called from OALInterruptInit to initialize mapping
  6 //  between IRQ and SYSINTR. It simply initialize mapping arrays.
  7 //
  8 VOID OALIntrMapInit()
  9 {
10     UINT32 i;
11
12     OALMSG(OAL_FUNC&&OAL_INTR, (L"+OALIntrMapInit\r\n"));
13
14     // Initialize interrupt maps
15     for (i = 0; i < SYSINTR_MAXIMUM; i++) {
16         g_oalSysIntr2Irq[i] = OAL_INTR_IRQ_UNDEFINED;
17     }
18     for (i = 0; i < OAL_INTR_IRQ_MAXIMUM; i++) {
19         g_oalIrq2SysIntr[i] = SYSINTR_UNDEFINED;
20     }
21
22     OALMSG(OAL_FUNC&&OAL_INTR, (L"-OALIntrMapInit\r\n"));
23 }
24
25 //------------------------------------------------------------------------------
26 //  静态映射中断在2440 5.0BSP没有使用到
27 //  Function:   OALIntrStaticTranslate
28 //
29 //  This function sets static translation between IRQ and SYSINTR. In most
30 //  cases it should not be used. Only exception is mapping for
31 //  SYSINTR_RTC_ALARM and obsolete device drivers.
32 //
33 VOID OALIntrStaticTranslate(UINT32 sysIntr, UINT32 irq)
34 {
35     OALMSG(OAL_FUNC&&OAL_INTR, (
36         L"+OALIntrStaticTranslate(%d, %d)\r\n", sysIntr, irq
37     ));
38     if (irq < OAL_INTR_IRQ_MAXIMUM && sysIntr < SYSINTR_MAXIMUM) {
39         g_oalSysIntr2Irq[sysIntr] = irq;
40         g_oalIrq2SysIntr[irq] = sysIntr;
41     }
42     OALMSG(OAL_FUNC&&OAL_INTR, (L"-OALIntrStaticTranslate\r\n"));
43 }
44
45 //------------------------------------------------------------------------------
46 //  这个函数作用很大，把物理中断转换成系统中断
47 //  Function:  OALIntrRequestSysIntr
48 //
49 //  This function allocate new SYSINTR for given IRQ and it there isn't
50 //  static mapping for this IRQ it will create it.
51 //
52 UINT32 OALIntrRequestSysIntr(UINT32 count, const UINT32 *pIrqs, UINT32 flags)
53 {
54     UINT32 irq, sysIntr;
55
56     OALMSG(OAL_INTR&&OAL_FUNC, (
57         L"+OALIntrRequestSysIntr(%d, 0x%08x, 0x%08x)\r\n", count, pIrqs, flags
58     ));
59
60     // Valid IRQ?
61     if (count != 1 || pIrqs[0] >= OAL_INTR_IRQ_MAXIMUM) {
62         sysIntr = SYSINTR_UNDEFINED;
63         goto cleanUp;
64     }
65     irq = pIrqs[0];
66
67     // If there is mapping for given irq check for special cases
68     if (g_oalIrq2SysIntr[irq] != SYSINTR_UNDEFINED) {
69         // If static mapping is requested we fail
70         if ((flags & OAL_INTR_STATIC) != 0) {
71             OALMSG(OAL_ERROR, (L"ERROR: OALIntrRequestSysIntr: "
72                L"Static mapping for IRQ %d already assigned\r\n", irq
73             ));
74             sysIntr = SYSINTR_UNDEFINED;
75             goto cleanUp;
76         }
77         // If we should translate, return existing SYSINTR
78         if ((flags & OAL_INTR_TRANSLATE) != 0) {
79             sysIntr = g_oalIrq2SysIntr[irq];
80             goto cleanUp;
81         }
82     }
83
84     // Find next available SYSINTR value

85     for (sysIntr = SYSINTR_FIRMWARE; sysIntr < SYSINTR_MAXIMUM; sysIntr++) {
86         if (g_oalSysIntr2Irq[sysIntr] == OAL_INTR_IRQ_UNDEFINED) break;
87     }
88
89     // Any available SYSINTRs left?
90     if (sysIntr >= SYSINTR_MAXIMUM) {
91         OALMSG(OAL_ERROR, (L"ERROR: OALIntrRequestSysIntr: "
92             L"No avaiable SYSINTR found\r\n"
93         ));
94         sysIntr = SYSINTR_UNDEFINED;
95         goto cleanUp;
96     }
97
98     // Make SYSINTR -> IRQ association.
99     g_oalSysIntr2Irq[sysIntr] = irq;
100
101     // Make IRQ -> SYSINTR association if required
102     if ((flags & OAL_INTR_DYNAMIC) != 0) goto cleanUp;
103     if (
104         g_oalIrq2SysIntr[irq] == SYSINTR_UNDEFINED ||
105         (flags & OAL_INTR_FORCE_STATIC) != 0
106     ) {
107         g_oalIrq2SysIntr[irq] = sysIntr;
108     }
109
110 cleanUp:
111     OALMSG(OAL_INTR&&OAL_FUNC, (
112         L"-OALIntrRequestSysIntr(sysIntr = %d)\r\n", sysIntr
113     ));
114     return sysIntr;
115 }
116
117 //------------------------------------------------------------------------------
118 //  释放系统中断
119 //  Function:  OALIntrReleaseSysIntr
120 //
121 //  This function release given SYSINTR and remove static mapping if exists.
122 //
123 BOOL OALIntrReleaseSysIntr(UINT32 sysIntr)
124 {
125     BOOL rc = FALSE;
126     UINT32 irq;
127
128     OALMSG(OAL_INTR&&OAL_FUNC, (L"+OALIntrReleaseSysIntr(%d)\r\n", sysIntr));
129
130     // Is the SYSINTR already released?
131     if (g_oalSysIntr2Irq[sysIntr] == OAL_INTR_IRQ_UNDEFINED) goto cleanUp;
132
133     // Remove the SYSINTR -> IRQ mapping
134     irq = g_oalSysIntr2Irq[sysIntr];
135     g_oalSysIntr2Irq[sysIntr] = OAL_INTR_IRQ_UNDEFINED;
136
137     // If we're releasing the SYSINTR directly mapped in the IRQ mapping,
138     // remove the IRQ mapping also
139     if (g_oalIrq2SysIntr[irq] == sysIntr) {
140         g_oalIrq2SysIntr[irq] = SYSINTR_UNDEFINED;
141     }
142
143 cleanUp:
144     OALMSG(OAL_INTR&&OAL_FUNC, (L"-OALIntrReleaseSysIntr(rc = %d)\r\n", rc));
145     return rc;
146 }
147 以上代码均来自C:\WINCE500\PLATFORM\COMMON\SRC\COMMON\INTR\BASE\map.c
148
149 //------------------------------------------------------------------------------

再来看OALIntrEnableIrqs这个函数是怎么实现的

OALIntrEnableIrqs

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-- 1 //------------------------------------------------------------------------------
2 //
3 //  Function:  OALIntrEnableIrqs
4 //
5 BOOL OALIntrEnableIrqs(UINT32 count, const UINT32 *pIrqs)
6 {
7     BOOL rc = TRUE;
8     UINT32 i, mask, irq;
9
10     OALMSG(OAL_INTR&&OAL_FUNC, (
11         L"+OALIntrEnableIrqs(%d, 0x%08x)\r\n", count, pIrqs
12     ));
13
14     for (i = 0; i < count; i++) {
15 #ifndef OAL_BSP_CALLBACKS
16         irq = pIrqs[i];
17 #else
18         // Give BSP chance to enable irq on subordinate interrupt controller
19         irq = BSPIntrEnableIrq(pIrqs[i]);
20 #endif
21         if (irq == OAL_INTR_IRQ_UNDEFINED) continue;
22         // Depending on IRQ number use internal or external mask register
23         if (irq <= IRQ_ADC) {
24             // Use interrupt mask register
25             CLRREG32(&g_pIntrRegs->INTMSK, 1 << irq);
26         } else if (irq <= IRQ_EINT7) {
27             // Use external mask register
28             CLRREG32(&g_pIntrRegs->INTMSK, 1 << IRQ_EINT4_7);
29             CLRREG32(&g_pPortRegs->EINTMASK, 1 << (irq - IRQ_EINT4 + 4));
30         } else if (irq <= IRQ_EINT23) {
31             // Use external mask register
32             mask = 1 << (irq - IRQ_EINT4 + 4);
33             OUTREG32(&g_pPortRegs->EINTPEND, mask);
34             CLRREG32(&g_pPortRegs->EINTMASK, mask);
35             mask = 1 << IRQ_EINT8_23;
36             if ((INREG32(&g_pIntrRegs->INTPND) & mask) != 0) {
37                 OUTREG32(&g_pIntrRegs->INTPND, mask);
38             }
39             CLRREG32( &g_pIntrRegs->INTMSK, 1 << IRQ_EINT8_23);
40         } else {
41             rc = FALSE;
42         }
43     }
44
45     OALMSG(OAL_INTR&&OAL_FUNC, (L"-OALIntrEnableIrqs(rc = %d)\r\n", rc));
46     return rc;
47 }

通过以上的分析，这个代码是比较明朗，但是我们还是不明白这个中断到底是如何申请的，现在找一些驱动的代码来看看，以简单的重启按键驱动为例子，发现这个InterruptInitialize函数起到初始化中断和绑定线程的作用，现在看看PB帮助。

This function initializes a hardware interrupt with the kernel. This initialization allows the device driver to register an event and enable the interrupt.

BOOL InterruptInitialize( 
DWORD idInt,
HANDLE hEvent,
LPVOID pvData,
DWORD cbData 
);

Parameters idInt [in] Interrupt identifier to be associated with this interrupt service thread (IST). hEvent [in] Event to be signaled when the interrupt is triggered. pvData [in] This parameter can be used as a pointer to a block of data that is passed to OEMInterruptEnable. The block of data can be initialization data, scratch space, and so on. cbData [in] Size of data pointed to by pvData. Return Values

TRUE indicates success; FALSE indicates failure.

Remarks

This function must be called before using the hEvent parameter, which provides a link between the idInt parameter and the SYSINTR value returned by an ISR.

The hEvent parameter can only be used in a WaitForSingleObject call to wait for the event to be triggered by the kernel.

A WaitForMultipleObjects call with hEvent will fail.

If you use hEvent in a call to WaitForSingleObject before you call InterruptInitialize, InterruptInitialize will fail.

Requirements

OS Versions: Windows CE 2.10 and later.
Header: Pkfuncs.h.
Link Library: Coredll.lib.——郁闷，不开源的。

从PB帮助可以知道，这个

This function initializes a hardware interrupt with the kernel. This initialization allows the device driver to register an event and enable the interrupt.

BOOL InterruptInitialize( 
DWORD idInt,
HANDLE hEvent,
LPVOID pvData,
DWORD cbData 
);

TRUE indicates success; FALSE indicates failure.

Remarks

This function must be called before using the hEvent parameter, which provides a link between the idInt parameter and the SYSINTR value returned by an ISR.

The hEvent parameter can only be used in a WaitForSingleObject call to wait for the event to be triggered by the kernel.

A WaitForMultipleObjects call with hEvent will fail.

If you use hEvent in a call to WaitForSingleObject before you call InterruptInitialize, InterruptInitialize will fail.

Requirements

OS Versions: Windows CE 2.10 and later.
Header: Pkfuncs.h.
Link Library: Coredll.lib.——郁闷，不开源的。

从PB帮助可以知道InterruptInitialize函数的功能是绑定线程和系统中断，并且调用OEMInterruptEnable使能中断

（When a device driver calls the InterruptInitialize kernel routine, the kernel then calls OEMInterruptEnable）

InterruptInitialize 函数使用的是系统中断来绑定线程的，那么这个物理中断是如何转换成系统中断的呢？这个5.0和4.2BSP是不同的。——答案是伟大的KernelIoControl函数，这个函数的具体用法请参照PB帮助吧。

This function provides the kernel with a generic I/O control for carrying out I/O operations.

BOOL KernelIoControl( 
DWORD dwIoControlCode,
LPVOID lpInBuf,
DWORD nInBufSize,
LPVOID lpOutBuf,
DWORD nOutBufSize,
LPDWORD lpBytesReturned 
);

Parameters dwIoControlCode [in] I/O control code, which should support the OAL I/O controls. For a list of these I/O controls, see OAL IOCTLs. lpInBuf [out] Pointer to a buffer that contains the data required to perform the operation.

Set to NULL if the dwIoControlCode parameter specifies an operation that does not require input data.

nInBufSize [in] Size, in bytes, of the buffer pointed to by lpInBuf. lpOutBuf [out] Pointer to a buffer that receives the output data for the operation.

Set to NULL if the dwIoControlCode parameter specifies an operation that does not produce output data.

nOutBufSize [in] Size, in bytes, of the buffer pointed to by lpOutBuf. lpBytesReturned [in] Long pointer to a variable that receives the size, in bytes, of the data stored in the buffer pointed to by lpOutBuf. Even when an operation produces no output data, and lpOutBuf is NULL, the KernelIoControl function uses the variable pointed to by lpBytesReturned. After such an operation, the value of the variable has no meaning. Return Values

TRUE indicates success; FALSE indicates failure.

Remarks

The kernel calls the OEMIoControl function when a device driver or application calls the kernel function KernelIoControl and passes an I/O control code. ——这个很关键，关于OEMIoControl 函数我在CSDN博客有介绍。这是实现中断转换的关键函数

This function is also called when the SystemParametersInfo function is called with SPI_GETOEMINFO or SPI_GETPLATFORMINFO.

The system is fully preemptible when this function is called. The kernel does no processing, but it passes all parameters directly to the function supplied by you.

This function is provided solely to allow your device driver or application to communicate with an OAL and its specific functionality.

现在就拿2440 5.0BSP串口驱动来具体分析一下

2440串口驱动

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-- 1     virtual BOOL Init() {
2         PHYSICAL_ADDRESS    ioPhysicalBase = { S3C2440A_BASE_REG_PA_IOPORT, 0};
3         ULONG               inIoSpace = 0;
4         if (TranslateBusAddr(m_hParent,Internal,0, ioPhysicalBase,&inIoSpace,&ioPhysicalBase)) {
5             // Map it if it is Memeory Mapped IO.
6             m_pIOPregs = (S3C2440A_IOPORT_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C2440A_IOPORT_REG),FALSE);
7         }
8         if (m_pIOPregs) {
9             DDKISRINFO ddi;
10 //读取注册表的IRQ的键值（这个键值还是物理中断的值，是中断偏移寄存器（INTOFFSET指定IRQ中断源）的值，4.2BSP就利用了这个东西）
11             if (GetIsrInfo(&ddi)== ERROR_SUCCESS &&
12                     KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &ddi.dwIrq, sizeof(UINT32), &ddi.dwSysintr, sizeof(UINT32), NULL))
13             {   //使用KernelIoControl完成物理中断和系统中断转换之后，又把这个系统中断写入到注册表中，下次读出的中断
14                   //就是系统中断了

这样就完成了物理中断和系统中断之间的转换，比4.2BSP的方法聪明多了。
15                 RegSetValueEx(DEVLOAD_SYSINTR_VALNAME,REG_DWORD,(PBYTE)&ddi.dwSysintr, sizeof(UINT32));
16             }
17             else
18                 return FALSE;
19             m_pDTRPort = (volatile ULONG *)&(m_pIOPregs->GPDDAT);
20             m_pDSRPort = (volatile ULONG *)&(m_pIOPregs->GPDDAT);
21             m_dwDTRPortNum = 0;
22             m_dwDSRPortNum = 1;
23
24             m_pIOPregs->GPHCON &= ~(0x3<<0 | 0x3<<2 | 0x3<<4 | 0x3<<6 );//tx,rx,rts,cts
25             m_pIOPregs->GPHCON |=  (0x2<<0 | 0x2<<2 | 0x2<<4 | 0x2<<6 );
26             m_pIOPregs->GPHCON |= (0x2<<0 | 0x2<<2);
27             m_pIOPregs->GPHUP  |= 0xf;
28
29             m_pIOPregs->GPDCON &= ~(0x3<<0 | 0x3<<2);//dtr,dsr
30             m_pIOPregs->GPDCON |= (0x1<<0 | 0x0<<2);
31             m_pIOPregs->GPDUP  |= 0x3;
32
33             return CPdd2440Uart::Init();//这里有大量的读注册表的操作，读出的中断是被上面修改过的系统中断了
34         }
35         return FALSE;
36     };
37
38 //---------------------------- 来看看这个再次读注册表的情况吧---------------------
39 BOOL CPdd2440Uart::Init()
40 {
41     if ( CSerialPDD::Init() && IsKeyOpened() && m_XmitFlushDone!=NULL) {
42         // IST Setup .--------Get IRQ forom regedit
43         DDKISRINFO ddi;
44        //再次读出注册表的中断，已经是系统中断了。
45         if (GetIsrInfo(&ddi)!=ERROR_SUCCESS) {
46             return FALSE;
47         }
48         m_dwSysIntr = ddi.dwSysintr;
49         if (m_dwSysIntr !=  MAXDWORD && m_dwSysIntr!=0 )
50             m_hISTEvent= CreateEvent(0,FALSE,FALSE,NULL);//创建事件，线程创建在后
51
52       //绑定中断PDD线程  ，和MDD中的线程有什么区别?
53       //ThreadRun
54         if (m_hISTEvent!=NULL)
55             InterruptInitialize(m_dwSysIntr,m_hISTEvent,0,0);
56         else
57             return FALSE;
58
59         // Get Device Index.
60         if (!GetRegValue(PC_REG_DEVINDEX_VAL_NAME, (PBYTE)&m_dwDevIndex, PC_REG_DEVINDEX_VAL_LEN)) {
61             m_dwDevIndex = 0;
62         }
63         if (!GetRegValue(PC_REG_SERIALWATERMARK_VAL_NAME,(PBYTE)&m_dwWaterMark,sizeof(DWORD))) {
64             m_dwWaterMark = 8;
65         }
66         if (!GetRegValue(PC_REG_2440UART_INTBIT_VAL_NAME,(PBYTE)&m_dwIntShift,sizeof(DWORD))) {
67             RETAILMSG(1,(TEXT("Registery does not have %s set. Drivers fail!!!\r\n"),PC_REG_2440UART_INTBIT_VAL_NAME));
68             m_dwIntShift =0;
69             return FALSE;
70         }
71         if (!GetRegValue(PC_REG_2440UART_IST_TIMEOUTS_VAL_NAME,(PBYTE)&m_dwISTTimeout, PC_REG_2440UART_IST_TIMEOUTS_VAL_LEN)) {
72             m_dwISTTimeout = INFINITE;
73         }
74         if (!MapHardware() || !CreateHardwareAccess()) {
75             return FALSE;
76         }
77
78         return TRUE;
79     }
80     return FALSE;
81 }
82
83
84

根据我以前在CSDN写的博客，这个KernelIoControl是通过IOCTL_HAL_REQUEST_SYSINTR达到目的，在File: oal_ioctl_tab.h有

{ IOCTL_HAL_REQUEST_SYSINTR, 0, OALIoCtlHalRequestSysIntr },

这个OALIoCtlHalRequestSysIntr正是前面实现物理中断和系统中断转换的函数。

OK，大功告成了！

参考资料：http://www.cnblogs.com/wogoyixikexie/archive/2009/02/04/1384012.html（OEMIoControl）

何宗健——《windows CE嵌入式系统》

*博客内容为网友个人发布，仅代表博主个人观点，如有侵权请联系工作人员删除。