openclos.c

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

    }

    //
    // We allocate 9 packets, 9 ndis buffers and 9 buffers to go with each
    // other.
    //

    NdisAllocatePacketPool(
        &status, 
        &pIrDevice->hRxPacketPool,
        NUM_RX_BUFFERS,
        16
        );

    if (status != NDIS_STATUS_SUCCESS)
    {
        goto done;
    }

    IrsirAddTrackedItem(
        MT_NDIS_PACKET_POOL,
        &pIrDevice->hRxPacketPool, 
        sizeof(NDIS_HANDLE)
        );

    NdisAllocateBufferPool(
        &status,
        &pIrDevice->hRxBufferPool,
        NUM_RX_BUFFERS
        );

    if (status != NDIS_STATUS_SUCCESS)
    {
        goto done;
    }

    IrsirAddTrackedItem(
        MT_NDIS_BUFFER_POOL,
        &pIrDevice->hRxBufferPool,
        sizeof(NDIS_HANDLE)
        );

    for (i = 0; i < NUM_RX_BUFFERS; i++)
    {
        PRX_BUFFER   pRxBuf;
        PNDIS_BUFFER pNdisBuffer;

        pRxBuf = IrsirAlloc(MT_IR_DEVICE_RECV, 
                            sizeof(RX_BUFFER) + RX_BUFFER_SIZE);

        if (pRxBuf == NULL)
        {
            status = NDIS_STATUS_RESOURCES;
            goto done;
        }

        pRxBuf->pbBuffer = (LPBYTE)pRxBuf + sizeof(RX_BUFFER);
        pRxBuf->cbBuffer = RX_BUFFER_SIZE;
        pRxBuf->cbData   = 0;

        NdisAllocatePacket(
             &status,
             &pRxBuf->pPacket,
             pIrDevice->hRxPacketPool
             );

        if (status != NDIS_STATUS_SUCCESS)
        {
            IrsirFree(pRxBuf);
            goto done;
        }

        IrsirAddTrackedItem(
            MT_NDIS_PACKET,
            &pRxBuf->pPacket,
            sizeof(NDIS_PACKET)
            );

        NdisAllocateBuffer(
            &status,
            &pNdisBuffer,
            pIrDevice->hRxBufferPool,
            pRxBuf->pbBuffer,
            pRxBuf->cbBuffer
            );

        if (status != NDIS_STATUS_SUCCESS)
        {
            NdisFreePacket(pRxBuf->pPacket);
            IrsirDelTrackedItem(pRxBuf->pPacket);
            IrsirFree(pRxBuf);
            goto done;
        }

        IrsirAddTrackedItem(
            MT_NDIS_BUFFER,
            pNdisBuffer,
            sizeof(NDIS_BUFFER)
            );

        // Chain buffer to packet.
        NdisChainBufferAtFront(pRxBuf->pPacket, pNdisBuffer);

        // Put on free list.
        InsertTailList( &pIrDevice->RxBufFree, &pRxBuf->Linkage);
    }

done:

    if (status == NDIS_STATUS_SUCCESS)
    {
        status = InitializeFIR(pIrDevice);
    }

    if (status != NDIS_STATUS_SUCCESS)
    {
        DeinitializeIrDevice(pIrDevice);
    }
    DEBUGMSG(ZONE_INIT, (TEXT("-InitializeIrDevice [0x%.8X]\r\n"), status));
    
    return (status);
}

/*++

 Function:       DeinitializeIrDevice

 Description:    Releases all memory associated with the IR device object
                 except the device object memory itself.

 Arguments:
    
    pIrDevice - Pointer to the device object to free.

 Returns:

    NDIS_STATUS_SUCCESS

 Comments:

--*/

NDIS_STATUS
DeinitializeIrDevice(
    IN OUT PIR_DEVICE pIrDevice
    )
{
    PRX_BUFFER   pRxBuf;
    PNDIS_BUFFER pNdisBuffer;

    // Assume NDIS won't reset/halt while pending sends.
    ASSERT(pIrDevice->pSendActive == NULL);
    ASSERT(pIrDevice->pSendHead == NULL);
    ASSERT(pIrDevice->pSendTail == NULL);

    DEBUGMSG(ZONE_INIT, (TEXT("+DeinitializeIrDevice(0x%.8X)\r\n"), pIrDevice));

    DeinitializeFIR(pIrDevice);
    
    // Free the send buffer.
    if (pIrDevice->pSendBuf != NULL)
    {
        IrsirFree(pIrDevice->pSendBuf);
        pIrDevice->pSendBuf = NULL;
    }

    // Free the serial device rx buffer.
    if (pIrDevice->lpRxBuf != NULL)
    {
        IrsirFree(pIrDevice->lpRxBuf);
        pIrDevice->lpRxBuf = NULL;
    }

    // Free our receive buffers/packets on the free list.
    while (IsListEmpty(&pIrDevice->RxBufFree) == FALSE)
    {
        pRxBuf = (PRX_BUFFER)RemoveHeadList(&pIrDevice->RxBufFree);

        ASSERT(pRxBuf != NULL);
        ASSERT((PLIST_ENTRY)pRxBuf != &pIrDevice->RxBufFree);
        ASSERT(pRxBuf->pPacket != NULL);

        NdisUnchainBufferAtFront(pRxBuf->pPacket, &pNdisBuffer);
        ASSERT(pNdisBuffer != NULL);

        NdisFreeBuffer(pNdisBuffer);
        IrsirDelTrackedItem(pNdisBuffer);

        NdisFreePacket(pRxBuf->pPacket);
        IrsirDelTrackedItem(pRxBuf->pPacket);

        IrsirFree(pRxBuf); // Deletes data buffer as well.
    }

    // Assume NDIS won't reset/halt while the protocol hasn't returned
    // some of our buffers.
    ASSERT(IsListEmpty(&pIrDevice->RxBufPending));

    // Free packet pool.
    if (pIrDevice->hRxPacketPool != NULL)
    {
        NdisFreePacketPool(pIrDevice->hRxPacketPool);
        IrsirDelTrackedItem(pIrDevice->hRxPacketPool);
        pIrDevice->hRxPacketPool = NULL;
    }

    // Free buffer pool.
    if (pIrDevice->hRxBufferPool != NULL)
    {
        NdisFreeBufferPool(pIrDevice->hRxBufferPool);
        IrsirDelTrackedItem(pIrDevice->hRxBufferPool);
        pIrDevice->hRxBufferPool = NULL;
    }

    NdisFreeSpinLock(&pIrDevice->slDevice);

    DEBUGMSG(ZONE_INIT, (TEXT("-DeinitializeIrDevice [SUCCESS]\r\n")));
    
    return (NDIS_STATUS_SUCCESS);
}

/*++

 Function:       GetDeviceConfiguration

 Description:    Gets the device configuration from the registry.

 Arguments:

    pIrDevice    - Pointer to IR device object.
    
    hConfigCtxt  - Handle to registry device configuration.

 Returns:

    NDIS_STATUS Code.
    
        Success - NDIS_STATUS_SUCCESS.
        
        Failure - NDIS_STATUS_Xxx.

 Comments:

--*/

NDIS_STATUS
GetDeviceConfiguration(
    IN OUT PIR_DEVICE pIrDevice,
    IN     HANDLE     hConfigCtxt
    )
{
    NDIS_STATUS                   status;
    PNDIS_CONFIGURATION_PARAMETER pConfigParam;

    NDIS_HANDLE hConfig          = NULL;
    NDIS_STRING regKeyPort       = NDIS_STRING_CONST("Port");
    NDIS_STRING regKeyInternalIR = NDIS_STRING_CONST("IntIR");
    NDIS_STRING regKeyDongleType = NDIS_STRING_CONST("TransceiverType");
    NDIS_STRING regKeyBaud       = NDIS_STRING_CONST("Baud");

    DWORD dwRegSpeedMask;
    DWORD dwUartSpeedMask;

    HANDLE   hSerial;
    WCHAR    lpszPortName[64];

    DEBUGMSG(ZONE_INIT,
             (TEXT("+GetDeviceConfiguration(0x%.8X, 0x%.8X)\r\n"), 
              pIrDevice, hConfigCtxt)
             );

    //
    // Get device configuration from registry.
    //

    NdisOpenConfiguration(
        &status,
        &hConfig,
        hConfigCtxt
        );

    if (status != NDIS_STATUS_SUCCESS)
    {
        goto done;
    }

    // Get serial port.
    NdisReadConfiguration(
        &status,
        &pConfigParam,
        hConfig,
        &regKeyPort,
        NdisParameterInteger
        );

    if (status == NDIS_STATUS_SUCCESS)
    {
        pIrDevice->dwPort = (DWORD)pConfigParam->ParameterData.IntegerData;
    }
    else
    {
        goto done;
    }

    // Get transceiver type.
    NdisReadConfiguration(
        &status,
        &pConfigParam,
        hConfig,
        &regKeyDongleType,     
        NdisParameterInteger
        );

    if (status == NDIS_STATUS_SUCCESS)
    {
        pIrDevice->tTransceiver = 
            (IR_TRANSCEIVER_TYPE)pConfigParam->ParameterData.IntegerData;
    }
    else
    {
        goto done;
    }

    // Get boolean if internal IR device.
    NdisReadConfiguration(
        &status,
        &pConfigParam,
        hConfig,
        &regKeyInternalIR,
        NdisParameterInteger
        );

    if (status == NDIS_STATUS_SUCCESS)
    {
        pIrDevice->fIntIR = (BOOL)pConfigParam->ParameterData.IntegerData;
    }
    else
    {
        goto done;
    }

    // Get speed mask - optional.
    NdisReadConfiguration(
        &status,
        &pConfigParam,
        hConfig,
        &regKeyBaud,
        NdisParameterHexInteger
        );

    if (status == NDIS_STATUS_SUCCESS)
    {
        dwRegSpeedMask = pConfigParam->ParameterData.IntegerData;
    }
    else
    {
        dwRegSpeedMask = ALL_SLOW_IRDA_SPEEDS;
    }

    //
    // Initialize the dongle interface.
    //

    switch (pIrDevice->tTransceiver)
    {
        case STANDARD_UART:
            pIrDevice->IDongle.Initialize   = StdUartInit;
            pIrDevice->IDongle.Deinitialize = StdUartDeinit;
            pIrDevice->IDongle.SetSpeed     = StdUartSetSpeed;
            pIrDevice->IDongle.GetCaps      = StdUartGetCaps;
            break;

        case ESI_9680:
            pIrDevice->IDongle.Initialize   = EsiInit;
            pIrDevice->IDongle.Deinitialize = EsiDeinit;
            pIrDevice->IDongle.SetSpeed     = EsiSetSpeed;
            pIrDevice->IDongle.GetCaps      = EsiGetCaps;
            break;

        default:
            status = NDIS_STATUS_FAILURE;
            goto done;
    }

    DEBUGMSG(ZONE_INIT,
             (TEXT("IrDevice Configuration (0x%.8X): COM%d, %s, %s.\r\n"),
              pIrDevice, pIrDevice->dwPort,
              (pIrDevice->tTransceiver == ESI_9680) ? 
                    TEXT("ESI_9680") : TEXT("Standard UART"),
              (pIrDevice->fIntIR == TRUE) ?
                    TEXT("Internal dongle") : TEXT("External dongle"))
             );

    status = pIrDevice->IDongle.GetCaps(
        &pIrDevice->capsDongle
        );
    ASSERT(status == NDIS_STATUS_SUCCESS);
    
    //
    // Open the COM port now to get supported baud rates and then close.
    // If for some reason we cannot open the port now, we will just
    // assume that all slow IR speeds are supported.
    // We will open and close the COM port since we know we won't really
    // open it until we get an OID_IRDA_REACQUIRE_HW_RESOURCES.
    //

    wsprintf(lpszPortName, TEXT("COM%d:"), pIrDevice->dwPort);

    dwUartSpeedMask = 
        BAUD_2400     |
        BAUD_9600     |
        BAUD_19200    |
        BAUD_38400    |
        BAUD_57600    |
        BAUD_115200;

    hSerial = CreateFile(
        lpszPortName,
        GENERIC_READ | GENERIC_WRITE,
        0,
        NULL,
        OPEN_EXISTING,
        0,
        NULL
        );

    if (hSerial != INVALID_HANDLE_VALUE)
    {
        COMMPROP CommProp;
        if (GetCommProperties(hSerial, &CommProp) == TRUE)
        {
            dwUartSpeedMask = CommProp.dwSettableBaud;
            DEBUGMSG(ZONE_INIT,
                (TEXT("GetCommProp(COM%d) Settable baud = 0x%x\r\n"),
                 pIrDevice->dwPort, dwUartSpeedMask));
        }
        CloseHandle(hSerial);
    }

    dwUartSpeedMask |= ( NDIS_IRDA_SPEED_576K  |
                         NDIS_IRDA_SPEED_1152K |
                         NDIS_IRDA_SPEED_4M     );

    //
    // Need to get supported speeds:
    // 1) Dongle caps.
    // 2) Registry.
    // 3) GetCommProperties.
    //

    pIrDevice->dwSupportedSpeedsMask = MergeSpeedMasks(
        pIrDevice->capsDongle.dwSpeedMask,
        dwRegSpeedMask,
        dwUartSpeedMask);

done:

    if (hConfig != NULL)
    {