Windows CE 6.0的内核传输无关层（KITL）分析(3)

 
OEMKitlStartup 函数首先完成KITL所需参数的检测和配置，通过调用OALArgsInit和OALArgsQuery检测并配置KITL所需的参数，如果OEMs商家在这两函数中没有配置KITL参数，则pKITLArgs指针为空，就采用默认的配置。亿道公司的EELiod PXA270 ARM开发平台采用LAN91C111芯片作为网卡控制，其中OAL_KITL_FLAGS_ENABLED | OAL_KITL_FLAGS_DHCP | OAL_KITL_FLAGS_VMINI标志表明在该平台中使用DHCP和VMINI（Virtual
Miniport），且使能KITL传输。参数配置成功后，调用OALKitlInit 函数初始化KITL。

$(_PLATFORMROOT)\xsbase270\src\oal\Kitl\Kitl.c
BOOL OEMKitlStartup (void)
{
    BOOL rc = FALSE;
    OAL_KITL_ARGS *pKITLArgs, KITLArgs;
    CHAR *pszDeviceId;
    KITL_RETAILMSG(ZONE_KITL_OAL, ("+OEMKitlStartup\r\n"));
    // Check and initialize the BSP Args area
    OALArgsInit((BSP_ARGS *) IMAGE_SHARE_ARGS_UA_START);
    // Look for bootargs left by the bootloader or left over from an earlier boot.
    pKITLArgs   = (OAL_KITL_ARGS*) OALArgsQuery(OAL_ARGS_QUERY_KITL);
     KITLOutputDebugString("---In OEMKitlStartup: MAC Address: %x-%x-%x\r\n",pKITLArgs->mac[0],pKITLArgs->mac[1],pKITLArgs->mac[2]);
    pszDeviceId = (CHAR*) OALArgsQuery(OAL_ARGS_QUERY_DEVID);
   // If no KITL arguments were found (typically provided by the bootloader), then select
    // some default settings.
    if (pKITLArgs == NULL)
    {
         KITLOutputDebugString("pKITLArgs is NULL\r\n");
        memset(&KITLArgs, 0, sizeof(OAL_KITL_ARGS));
        // By default, enable: KITL, DHCP, and VMINI...
        KITLArgs.flags = (OAL_KITL_FLAGS_ENABLED | OAL_KITL_FLAGS_DHCP | OAL_KITL_FLAGS_VMINI);
        // Use built-in LAN91C111 controller for KITL.
        KITLArgs.devLoc.IfcType     = Internal;
        KITLArgs.devLoc.BusNumber   = 0;
        KITLArgs.devLoc.PhysicalLoc = (PVOID)(XSBASE270_BASE_REG_PA_SMSC_ETHERNET + 0x300);
        KITLArgs.devLoc.LogicalLoc  = (DWORD)KITLArgs.devLoc.PhysicalLoc;
        pKITLArgs = &KITLArgs;
    }
    if (pszDeviceId == NULL)
    {
        KITL_RETAILMSG(ZONE_ERROR, ("ERROR: Unable to locate Device ID buffer\r\n"));
    }
    else if (pszDeviceId[0] == '\0')
    {
        // We don't yet have the Ethernet controller's MAC address (this is obtained
        // in the initialization function.  Store a base name for the device, and
        // signal that it should be extended with the MAC address later.
        strncpy(pszDeviceId, BSP_DEVICE_PREFIX, OAL_KITL_ID_SIZE);
        pKITLArgs->flags |= OAL_KITL_FLAGS_EXTNAME;
    }
    // Finally call KITL library.
    rc = OALKitlInit(pszDeviceId, pKITLArgs, g_kitlDevices);
    KITL_RETAILMSG(ZONE_KITL_OAL, ("-OEMKitlStartup(rc = %d)\r\n", rc));
    return(rc);
}

OALKitlInit函数本质上是输出OEMKitlStartup函数中所配置的KITL参数调试信息和检测参数的有效性，同时通过调用OALKitlFindDevice函数查找KITL设备，在保存KITL配置信息后再调用内核的KitlInit 函数对KITL正是初始化
$(_PLATFORMROOT)\common\src\common\Kitl\Kitl.c
BOOL OALKitlInit(
    LPCSTR deviceId, OAL_KITL_ARGS *pArgs, OAL_KITL_DEVICE *pDevice
) {
    BOOL rc = FALSE;
    KITL_RETAILMSG(ZONE_KITL_OAL, (
        "+OALKitlInit('%hs', 0x%08x - %d/%d/0x%08x, 0x%08x)\r\n", deviceId,

        pArgs->flags, pArgs->devLoc.IfcType, pArgs->devLoc.BusNumber,

        pArgs->devLoc.LogicalLoc, pDevice
    ));
    // Display KITL parameters
……
    // If KITL is disabled simply return
    if ((pArgs->flags & OAL_KITL_FLAGS_ENABLED) == 0) {
        KITL_RETAILMSG(ZONE_WARNING, ("WARN: OALKitlInit: KITL Disabled\r\n"));
        rc = TRUE;
        goto cleanUp;   
 }
    // Find if we support device on given location
    g_kitlState.pDevice = OALKitlFindDevice(&pArgs->devLoc, pDevice);
    if (g_kitlState.pDevice == NULL) {
        KITL_RETAILMSG(ZONE_ERROR, (
            "ERROR: OALKitlInit: No supported KITL device at interface %d "
            "bus %d location 0x%08x\r\n", pArgs->devLoc.IfcType,
            pArgs->devLoc.BusNumber, pArgs->devLoc.LogicalLoc
        ));
        goto cleanUp;    }  
    // Save KITL configuration
    memcpy(g_kitlState.deviceId, deviceId, sizeof(g_kitlState.deviceId));
    memcpy(&g_kitlState.args, pArgs, sizeof(g_kitlState.args));       

    // Start KITL in desired mode
    if (!KitlInit((pArgs->flags & OAL_KITL_FLAGS_PASSIVE) == 0)) {
        KITL_RETAILMSG(ZONE_ERROR, ("ERROR: OALKitlInit: KitlInit failed\r\n"));
        goto cleanUp;    }
    rc = TRUE; 
cleanUp:
    KITL_RETAILMSG(ZONE_KITL_OAL, ("-OALKitlInit(rc = %d)\r\n", rc));
    return rc;
}
 
KitlInit函数属于KITL内核，编译在kitlcore.lib中，该函数初始化基于调试消息（KITL_SVC_DBGMSG）、文本shell和点对点文件系统（KITL_SVC_PPSH）和内核调试器（Kernel Debugger）三种默认KITL服务客户端。然后调用StartKitl函数启动KITL服务
$(_PRIVATEROOT)\WINCEOS\COREOS\NK\KITL\ethdbg.c
BOOL KitlInit (BOOL fStartKitl)
{
    // Initialize default clients
    NewClient (KITL_SVC_DBGMSG, KITL_SVCNAME_DBGMSG, FALSE);
    NewClient (KITL_SVC_PPSH,   KITL_SVCNAME_PPSH,   FALSE);
    NewClient (KITL_SVC_KDBG,   KITL_SVCNAME_KDBG,   FALSE);
    InitTimerList ();
    return fStartKitl? StartKitl (TRUE) : TRUE;
}
KitlInit函数的入口参数fStartKitl表明KITL包含的操作模式，当传入的参数为 TRUE 时，KITL工作在主动模式（active），这时目标平台启动时自动初始化像内核调试器（Kernel Debug）一样的所有默认的KITL客户服务，KITL服务然后再调用OEMKitlInit函数，并注册系统所需的所有默认客户服务，这种模式适合于那些具有固定连接的开发处理；当传入参数为
FALSE 时，KITL工作在被动模式（passive）,在这种模式下，设备启动时并不初始化KITL及其客户服务，KITL必须完成自身及其所有默认的客户服务的初始化，余下的过程跟主动模式一样。被动模式比较适合调试器不是必须的情况，它的好处是允许用户创建一个不必同桌面系统（PC）工具绑定在一起的设备，甚至可以为移动设备，当设备需要同桌面系统连接时，设备便初始化一个同桌面系统相连的KITL服务。目前所有的嵌入式移动设备都采用这个方式同PC相连（比如利用ActiveSync）。
但在设备启动时用户必须确定设备所进入的工作模式，Platform Builder 提供了一个KTS_PASSIVE_MODE标志符供用户选择KITL工作模式，在Platform Builder中，KITL工作模式默认设置为主动模式，即在设备启动时自动初始化KITL并建立一个连接，可以通过Platform
Builder的IDE中Connectivity Options菜单更该KITL的模式。从安装有Windows CE 6.0
的Visual Studio 2005中Target菜单中选择 Connectivity Options菜单，并弹出的对话框中选择“Core
Service Settings”，当“KITL Settings
”设置中的“Enable KITL on device boot”选中时，KITL为主动模式，当清除该选项时KITL为被动模式。



StartKitl 函数首先判断KITL启动条件，如果已经启动，则直接返回，否则先调用OEMKitlInit函数初始化网络硬件，同时填充KITL传输中极为重要KITLTRANSPORT.结构体内容，并对从OEMKitlInit函数中获取的KITLTRANSPORT结构体中的内容配置情况进行判断，同时对在KitlInit函数中初始化的三种客户服务进行注册。然后对KITL连接情况进行判断，在被动模下，还需要调用KITLInitializeInterrupt初始化并注册KITL中断（具体可参考KITLInitializeInterrupt实现部分）。
 
$(_PRIVATEROOT)\WINCEOS\COREOS\NK\KITL\ethdbg.c
static BOOL StartKitl (BOOL fInit)
{
    // KITL already started?
    if (!fInit && (KITLGlobalState & KITL_ST_DESKTOP_CONNECTED)) {
        return TRUE;
    }
     // Detect/initialize ethernet hardware, and return address information
    if (!OEMKitlInit (&Kitl))
        return FALSE;
    // verify that the Kitl structure is initialized.
    if (!Kitl.pfnDecode || !Kitl.pfnEncode || !Kitl.pfnRecv || !Kitl.pfnSend || !Kitl.pfnGetDevCfg || !Kitl.pfnSetHostCfg) {
        return FALSE;
    }
    // pfnEnableInt can not be null if using interrupt
    if (((UCHAR) KITL_SYSINTR_NOINTR != Kitl.Interrupt) && !Kitl.pfnEnableInt) {
        return FALSE;
    }
    if (Kitl.dwPhysBuffer || Kitl.dwPhysBufLen) {
        KITLOutputDebugString("\r\n!Kitl buffer specified by OAL is not required, ignore...\r\n");
    }
    Kitl.dwPhysBuffer = (DWORD)g_KitlBuffer;
    //Kitl.dwPhysBufLen = sizeof(g_KitlBuffer);
    Kitl.WindowSize = KITL_MAX_WINDOW_SIZE;
    KITLGlobalState |= KITL_ST_KITLSTARTED; // indicate (to kdstub) that KITL has started
    // If the initialized flag is already set, we are being called from the power on routine,
    // so reinit the HW, but not any state.
    if (!(KITLGlobalState & KITL_ST_ADAPTER_INITIALIZED)) {
        // perform the initial handshake with the desktop
        if (!KITLConnectToDesktop ()) {
            KITLOutputDebugString ("\r\n!Unable to establish KITL connection with desktop!\r\n");
            return FALSE;
        }
        // Set up kernel function pointers
        KITLGlobalState |= KITL_ST_ADAPTER_INITIALIZED;
        if ((Kitl.dwBootFlags & KITL_FL_DBGMSG)
            && KITLRegisterDfltClient (KITL_SVC_DBGMSG, 0, NULL, NULL)) {
            g_pNKGlobal->pfnWriteDebugString = KITLWriteDebugString;
        }
        if (Kitl.dwBootFlags & KITL_FL_PPSH) {
            KITLRegisterDfltClient (KITL_SVC_PPSH, 0, NULL, NULL);
        }
        // only perform cleanboot if it's connected at boot. Cleanboot flag is
        // ignored if it's started dynamically.
        if (fInit && (Kitl.dwBootFlags & KITL_FL_CLEANBOOT)) {
            NKForceCleanBoot();
        }
        // if OEM calls KitlInit (FALSE), KITLInitializeInterrupt will
        // not be called in SystemStartupFuc. We need to initialize
        // interrupt here (when RegisterClient is called)
        if (IsSystemReady () && !InSysCall ()) {
            KITLInitializeInterrupt ();
        }
    }
    return TRUE;
}
             
OEMKitlInit函数主要根据在OEMKitlStartup 函数保存的KITL所选用通信设备类型相应的调用不同的网络硬件初始化函数，如果采用以太网，则调用OALKitlEthInit，如果采用串行口，则调用OALKitlSerialInit函数，如果初始化成功，则对KITLTRANSPORT.结构体中的电源控制函数指针赋值，WinCE56.0移植的帮助文档中特意提到了两个函数指针。
$(_PLATFORMROOT)\common\src\common\Kitl\ Kitl.c        

BOOL OEMKitlInit(PKITLTRANSPORT pKitl)
{
    BOOL rc = FALSE;
 
    KITL_RETAILMSG(ZONE_KITL_OAL, ("+OEMKitlInit(0x%08x)\r\n", pKitl));
 
    switch (g_kitlState.pDevice->type) {
#ifdef KITL_ETHER    
    case OAL_KITL_TYPE_ETH:
        rc = OALKitlEthInit(
            g_kitlState.deviceId, g_kitlState.pDevice,
            &g_kitlState.args, pKitl
        );
        break;
#endif
#ifdef KITL_SERIAL
    case OAL_KITL_TYPE_SERIAL:
        rc = OALKitlSerialInit(
            g_kitlState.deviceId, g_kitlState.pDevice,
            &g_kitlState.args, pKitl
        );
        break;
#endif
    }
    if (rc) {
        pKitl->pfnPowerOn  = OALKitlPowerOn;
        pKitl->pfnPowerOff = OALKitlPowerOff;
    } else {
        pKitl->pfnPowerOn  = NULL;
        pKitl->pfnPowerOff = NULL;
    }
 
    KITL_RETAILMSG(ZONE_KITL_OAL, ("-OEMKitlInit(rc = %d)\r\n", rc));
    return rc;
}
 
OALKitlEthInit函数完成对以太网硬件设备进行初始化，其中比较关键的硬件的获取位置，即pDriver = (OAL_KITL_ETH_DRIVER*)pDevice->pDriver;该指针指向一个具体硬件设备的各种实现过程（EELiod平台，初始化-> pfnInit，对应LAN91CInit）,对亿道公司的EELiod开发平台，采用LAN91C111芯片，其对于的以太网设备实现结构体为OAL_ETHDRV_LAN91C，如下：并查询所使用的中断号。
#define OAL_ETHDRV_LAN91C   { \
    LAN91CInit, NULL, NULL, LAN91CSendFrame, LAN91CGetFrame, \
    LAN91CEnableInts, LAN91CDisableInts, \
    NULL, NULL,  LAN91CCurrentPacketFilter, LAN91CMulticastList \
}
并填充KITL传输结构体KITLTRANSPORT中的必须项和IPV4结构体中项，最后初始化并激活一个虚拟微型网桥（Virtual
Miniport bridge）。
 
$(_PLATFORMROOT)\\common\src\common\Kitl\Kitleth.c
BOOL OALKitlEthInit(
    LPSTR deviceId, OAL_KITL_DEVICE *pDevice, OAL_KITL_ARGS *pArgs,
    KITLTRANSPORT *pKitl
) {
    BOOL rc = FALSE;
    OAL_KITL_ETH_DRIVER *pDriver;
    UINT32 irq, sysIntr;
 
    KITL_RETAILMSG(ZONE_KITL_OAL, (
        "+OALKitlEthInit('%S', '%s', 0x%08x, 0x%08x)\r\n",
        deviceId, pDevice->name, pArgs, pKitl
    ));
    // Cast driver config parameter
    pDriver = (OAL_KITL_ETH_DRIVER*)pDevice->pDriver;
    if (pDriver == NULL) {
        KITL_RETAILMSG(ZONE_ERROR, ("ERROR: KITL device driver is NULL\r\n"));
        goto cleanUp;
    }
    // Call InitDmaBuffer if there is any
    if (pDriver->pfnInitDmaBuffer != NULL) {
        if (!pDriver->pfnInitDmaBuffer(
            (DWORD)g_oalKitlBuffer, sizeof(g_oalKitlBuffer)
        )) {
                KITL_RETAILMSG(ZONE_ERROR, (
                "ERROR: KITL call to pfnInitDmaBuffer failed\r\n"
            ));
            goto cleanUp;
        }
    }
    // Call pfnInit
    if (!pDriver->pfnInit(
        (UCHAR*)pArgs->devLoc.PhysicalLoc, pArgs->devLoc.LogicalLoc, pArgs->mac
    )) {
        KITL_RETAILMSG(ZONE_ERROR, ("ERROR: KITL call to pfnInit failed\r\n"));
        goto cleanUp;
    }
    // Extend name if flag is set
    if ((pArgs->flags & OAL_KITL_FLAGS_EXTNAME) != 0) {
        OALKitlCreateName(deviceId, pArgs->mac, deviceId);
    }
    // Now we know final name, print it
    KITL_RETAILMSG(ZONE_INIT, ("KITL: *** Device Name %s ***\r\n", deviceId));
    // Map and enable interrupt
    if ((pArgs->flags & OAL_KITL_FLAGS_POLL) != 0) {
        sysIntr = KITL_SYSINTR_NOINTR;
    } else {
        // Get IRQ, when interface is undefined use Pin as IRQ
        if (pArgs->devLoc.IfcType == InterfaceTypeUndefined) {
            irq = pArgs->devLoc.Pin;
        } else {
            if (!OEMIoControl(
                IOCTL_HAL_REQUEST_IRQ, &pArgs->devLoc, sizeof(pArgs->devLoc),
                &irq, sizeof(irq), NULL
            )) {               
                    KITL_RETAILMSG(ZONE_WARNING, (
                    "WARN: KITL can't obtain IRQ for KITL device\r\n"
                ));
                irq = OAL_INTR_IRQ_UNDEFINED;
            }
        }
        // Get SYSINTR for IRQ
        if (irq != OAL_INTR_IRQ_UNDEFINED) {
            UINT32 aIrqs[3];
 
            aIrqs[0] = -1;
            aIrqs[1] = (pArgs->devLoc.IfcType == InterfaceTypeUndefined)
                        ? OAL_INTR_TRANSLATE
                        : OAL_INTR_FORCE_STATIC;
            aIrqs[2] = irq;
            if (
                OEMIoControl(
                    IOCTL_HAL_REQUEST_SYSINTR, aIrqs, sizeof(aIrqs), &sysIntr,
                    sizeof(sysIntr), NULL
                ) && sysIntr != SYSINTR_UNDEFINED
            ) {               
                KITL_RETAILMSG(ZONE_INIT, ("KITL: using sysintr 0x%x\r\n", sysIntr));
            } else {
                KITL_RETAILMSG(ZONE_WARNING, (
                    "WARN: KITL can't obtain SYSINTR for IRQ %d\r\n", irq
                ));
                sysIntr = KITL_SYSINTR_NOINTR;
            }
        } else {
            sysIntr = KITL_SYSINTR_NOINTR;
        }
    }
    if (sysIntr == KITL_SYSINTR_NOINTR) {
        KITL_RETAILMSG(ZONE_WARNING, (
            "WARN: KITL will run in polling mode\r\n"
        ));
    }
    //-----------------------------------------------------------------------
    // Initalize KITL transport structure
    //-----------------------------------------------------------------------
    memcpy(pKitl->szName, deviceId, sizeof(pKitl->szName));
    pKitl->Interrupt     = (UCHAR)sysIntr;
    pKitl->WindowSize    = OAL_KITL_WINDOW_SIZE;
    pKitl->FrmHdrSize    = KitlEthGetFrameHdrSize();
    pKitl->dwPhysBuffer  = 0;
    pKitl->dwPhysBufLen  = 0;
    pKitl->pfnEncode     = KitlEthEncode;
    pKitl->pfnDecode     = KitlEthDecode;
    pKitl->pfnSend       = KitlEthSend;
    pKitl->pfnRecv       = KitlEthRecv;
    pKitl->pfnEnableInt  = KitlEthEnableInt;
    pKitl->pfnGetDevCfg  = KitlEthGetDevCfg;
    pKitl->pfnSetHostCfg = KitlEthSetHostCfg;
    //-----------------------------------------------------------------------
    // Initalize KITL IP4 state structure
    //-----------------------------------------------------------------------
    g_kitlEthState.pDriver = pDriver;
    g_kitlEthState.flags = pArgs->flags;
    g_kitlEthState.deviceMAC[0] = (UINT8)pArgs->mac[0];
    g_kitlEthState.deviceMAC[1] = (UINT8)(pArgs->mac[0] >> 8);
    g_kitlEthState.deviceMAC[2] = (UINT8)pArgs->mac[1];
    g_kitlEthState.deviceMAC[3] = (UINT8)(pArgs->mac[1] >> 8);
    g_kitlEthState.deviceMAC[4] = (UINT8)pArgs->mac[2];
    g_kitlEthState.deviceMAC[5] = (UINT8)(pArgs->mac[2] >> 8);
    g_kitlEthState.deviceIP = pArgs->ipAddress;
 
    g_kitlEthState.kitlServerMAC[0] = 0xFF;
    g_kitlEthState.kitlServerMAC[1] = 0xFF;
    g_kitlEthState.kitlServerMAC[2] = 0xFF;
    g_kitlEthState.kitlServerMAC[3] = 0xFF;
    g_kitlEthState.kitlServerMAC[4] = 0xFF;
    g_kitlEthState.kitlServerMAC[5] = 0xFF;
    g_kitlEthState.kitlServerIP = 0xFFFFFFFF;
    g_kitlEthState.kitlServerPort = htons(KITL_SERVER_PORT);
 
    g_kitlEthState.dhcpXId = pArgs->mac[2] | 0x17016414;
    g_kitlEthState.dhcpState = DHCP_BOUND;
 
    // Get or renew DHCP address
    if ((pArgs->flags & OAL_KITL_FLAGS_DHCP) != 0) {
        // KITL isn't running let use direct functions for send/receive
        g_kitlEthState.pfnSend = pKitl->pfnSend;
        g_kitlEthState.pfnRecv = pKitl->pfnRecv;
        // Get or renew address from DHCP server
        GetAddressDHCP(pArgs->ipAddress);
    }
    // When KITL is running we should call sync function for send
    g_kitlEthState.pfnSend = KitlSendRawData;
    // There should not be direct receive
    g_kitlEthState.pfnRecv = NULL;
 
#ifdef KITL_ETHER    
    // Activate VMINI bridge...
    if ((pArgs->flags & OAL_KITL_FLAGS_VMINI) != 0) {
        VBridgeInit();
        VBridgeKSetLocalMacAddress((char*)pArgs->mac);
    }
#endif
    // Result depends on fact if we get IP address
    rc = (g_kitlEthState.deviceIP != 0);
   cleanUp:
    KITL_RETAILMSG(ZONE_KITL_OAL, ("-OALKitlEthInit(rc = %d)\r\n", rc));
    return rc;
}