async.c

winddk src目录下的WDM源码压缩!

            _ultoa(pAsyncRead->nBlockSize, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_READ_BLOCK_SIZE, tmpBuff);

            if (pAsyncRead->fulFlags & ASYNC_FLAGS_NONINCREMENTING)
                CheckDlgButton( hDlg, IDC_ASYNC_READ_FLAG_NON_INCREMENT, BST_CHECKED);

            if (pAsyncRead->bGetGeneration)
                CheckDlgButton( hDlg, IDC_ASYNC_READ_GET_GENERATION, BST_CHECKED);

            _ultoa(pAsyncRead->ulGeneration, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_READ_GENERATION_COUNT, tmpBuff);

            return(TRUE); // WM_INITDIALOG

        case WM_COMMAND:

            switch (LOWORD(wParam)) {

                case IDOK:

                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_READ_USE_BUS_NODE_NUMBER))
                        pAsyncRead->bRawMode = TRUE;
                    else
                        pAsyncRead->bRawMode = FALSE;

                    GetDlgItemText(hDlg, IDC_ASYNC_READ_BUS_NUMBER, tmpBuff, STRING_SIZE);
                    pAsyncRead->DestinationAddress.IA_Destination_ID.NA_Bus_Number = (USHORT)strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_READ_NODE_NUMBER, tmpBuff, STRING_SIZE);
                    pAsyncRead->DestinationAddress.IA_Destination_ID.NA_Node_Number = (USHORT)strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_READ_OFFSET_HIGH, tmpBuff, STRING_SIZE);
                    pAsyncRead->DestinationAddress.IA_Destination_Offset.Off_High = (USHORT)strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_READ_OFFSET_LOW, tmpBuff, STRING_SIZE);
                    pAsyncRead->DestinationAddress.IA_Destination_Offset.Off_Low = strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_READ_BYTES_TO_READ, tmpBuff, STRING_SIZE);
                    pAsyncRead->nNumberOfBytesToRead = strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_READ_BLOCK_SIZE, tmpBuff, STRING_SIZE);
                    pAsyncRead->nBlockSize = strtoul(tmpBuff, NULL, 16);

                    pAsyncRead->fulFlags = 0;
                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_READ_FLAG_NON_INCREMENT))
                        pAsyncRead->fulFlags |= ASYNC_FLAGS_NONINCREMENTING;

                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_READ_GET_GENERATION))
                        pAsyncRead->bGetGeneration = TRUE;
                    else
                        pAsyncRead->bGetGeneration = FALSE;

                    GetDlgItemText(hDlg, IDC_ASYNC_READ_GENERATION_COUNT, tmpBuff, STRING_SIZE);
                    pAsyncRead->ulGeneration = strtoul(tmpBuff, NULL, 16);

                    EndDialog(hDlg, TRUE);
                    return(TRUE); // IDOK

                case IDCANCEL:
                    EndDialog(hDlg, FALSE);
                    return(TRUE); // IDCANCEL

                default:
                    return(TRUE); // default

            } // switch

            break; // WM_COMMAND

        default:
            break; // default

    } // switch

    return(FALSE);
} // AsyncReadDlgProc

void
w1394_AsyncRead(
    HWND    hWnd,
    PSTR    szDeviceName
    )
{
    ASYNC_READ      asyncRead;
    DWORD           dwRet;

    TRACE(TL_TRACE, (hWnd, "Enter w1394_AsyncRead\r\n"));

    asyncRead.bRawMode = FALSE;
    asyncRead.bGetGeneration = TRUE;
    asyncRead.DestinationAddress.IA_Destination_ID.NA_Bus_Number = 0x3FF;
    asyncRead.DestinationAddress.IA_Destination_ID.NA_Node_Number = 0;
    asyncRead.DestinationAddress.IA_Destination_Offset.Off_High = 0xFFFF;
    asyncRead.DestinationAddress.IA_Destination_Offset.Off_Low = 0xF0000400;
    asyncRead.nNumberOfBytesToRead = sizeof(ULONG);
    asyncRead.nBlockSize = 0;
    asyncRead.fulFlags = 0;
    asyncRead.ulGeneration = 0;

    if (DialogBoxParam( (HINSTANCE) GetWindowLongPtr(hWnd, GWLP_HINSTANCE),
                        "AsyncRead",
                        hWnd,
                        AsyncReadDlgProc,
                        (LPARAM)&asyncRead
                        )) {

        dwRet = AsyncRead( hWnd,
                           szDeviceName,
                           &asyncRead,
                           TRUE
                           );
    }

    TRACE(TL_TRACE, (hWnd, "Exit w1394_AsyncRead\r\n"));
    return;
} // w1394_AsyncRead

INT_PTR CALLBACK
AsyncWriteDlgProc(
    HWND        hDlg,
    UINT        uMsg,
    WPARAM      wParam,
    LPARAM      lParam
    )
{
    static PASYNC_WRITE     pAsyncWrite;
    static CHAR             tmpBuff[STRING_SIZE];

    switch (uMsg) {

        case WM_INITDIALOG:

            pAsyncWrite = (PASYNC_WRITE)lParam;

            if (pAsyncWrite->bRawMode)
                CheckDlgButton( hDlg, IDC_ASYNC_WRITE_USE_BUS_NODE_NUMBER, BST_CHECKED);

            _ultoa(pAsyncWrite->DestinationAddress.IA_Destination_ID.NA_Bus_Number, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_WRITE_BUS_NUMBER, tmpBuff);

            _ultoa(pAsyncWrite->DestinationAddress.IA_Destination_ID.NA_Node_Number, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_WRITE_NODE_NUMBER, tmpBuff);

            _ultoa(pAsyncWrite->DestinationAddress.IA_Destination_Offset.Off_High, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_WRITE_OFFSET_HIGH, tmpBuff);

            _ultoa(pAsyncWrite->DestinationAddress.IA_Destination_Offset.Off_Low, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_WRITE_OFFSET_LOW, tmpBuff);

            _ultoa(pAsyncWrite->nNumberOfBytesToWrite, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_WRITE_BYTES_TO_WRITE, tmpBuff);

            _ultoa(pAsyncWrite->nBlockSize, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_WRITE_BLOCK_SIZE, tmpBuff);

            if (pAsyncWrite->fulFlags & ASYNC_FLAGS_NONINCREMENTING)
                CheckDlgButton( hDlg, IDC_ASYNC_WRITE_FLAG_NON_INCRMENT, BST_CHECKED);

            if (pAsyncWrite->fulFlags & ASYNC_FLAGS_NO_STATUS)
                CheckDlgButton( hDlg, IDC_ASYNC_WRITE_FLAG_NO_STATUS, BST_CHECKED);

            if (pAsyncWrite->bGetGeneration)
                CheckDlgButton( hDlg, IDC_ASYNC_WRITE_GET_GENERATION, BST_CHECKED);

            _ultoa(pAsyncWrite->ulGeneration, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_WRITE_GENERATION_COUNT, tmpBuff);

            return(TRUE); // WM_INITDIALOG

        case WM_COMMAND:

            switch (LOWORD(wParam)) {

                case IDOK:

                   if (IsDlgButtonChecked(hDlg, IDC_ASYNC_WRITE_USE_BUS_NODE_NUMBER))
                        pAsyncWrite->bRawMode = TRUE;
                    else
                        pAsyncWrite->bRawMode = FALSE;

                    GetDlgItemText(hDlg, IDC_ASYNC_WRITE_BUS_NUMBER, tmpBuff, STRING_SIZE);
                    pAsyncWrite->DestinationAddress.IA_Destination_ID.NA_Bus_Number = (USHORT)strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_WRITE_NODE_NUMBER, tmpBuff, STRING_SIZE);
                    pAsyncWrite->DestinationAddress.IA_Destination_ID.NA_Node_Number = (USHORT)strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_WRITE_OFFSET_HIGH, tmpBuff, STRING_SIZE);
                    pAsyncWrite->DestinationAddress.IA_Destination_Offset.Off_High = (USHORT)strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_WRITE_OFFSET_LOW, tmpBuff, STRING_SIZE);
                    pAsyncWrite->DestinationAddress.IA_Destination_Offset.Off_Low = strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_WRITE_BYTES_TO_WRITE, tmpBuff, STRING_SIZE);
                    pAsyncWrite->nNumberOfBytesToWrite = strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_WRITE_BLOCK_SIZE, tmpBuff, STRING_SIZE);
                    pAsyncWrite->nBlockSize = strtoul(tmpBuff, NULL, 16);

                    pAsyncWrite->fulFlags = 0;
                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_WRITE_FLAG_NON_INCRMENT))
                        pAsyncWrite->fulFlags |= ASYNC_FLAGS_NONINCREMENTING;

                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_WRITE_FLAG_NO_STATUS))
                        pAsyncWrite->fulFlags |= ASYNC_FLAGS_NO_STATUS;


                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_WRITE_GET_GENERATION))
                        pAsyncWrite->bGetGeneration = TRUE;
                    else
                        pAsyncWrite->bGetGeneration = FALSE;

                    GetDlgItemText(hDlg, IDC_ASYNC_WRITE_GENERATION_COUNT, tmpBuff, STRING_SIZE);
                    pAsyncWrite->ulGeneration = strtoul(tmpBuff, NULL, 16);

                    EndDialog(hDlg, TRUE);
                    return(TRUE); // IDOK

                case IDCANCEL:
                    EndDialog(hDlg, FALSE);
                    return(TRUE); // IDCANCEL

                default:
                    return(TRUE); // default

            } // switch

            break; // WM_COMMAND

        default:
            break; // default

    } // switch

    return(FALSE);
} // AsyncWriteDlgProc

void
w1394_AsyncWrite(
    HWND    hWnd,
    PSTR    szDeviceName
    )
{
    ASYNC_WRITE     asyncWrite;
    DWORD           dwRet;
    ULONG           i;

    TRACE(TL_TRACE, (hWnd, "Enter w1394_AsyncWrite\r\n"));

    asyncWrite.bRawMode = FALSE;
    asyncWrite.bGetGeneration = TRUE;
    asyncWrite.DestinationAddress.IA_Destination_ID.NA_Bus_Number = 0x3FF;
    asyncWrite.DestinationAddress.IA_Destination_ID.NA_Node_Number = 0;
    asyncWrite.DestinationAddress.IA_Destination_Offset.Off_High = 0;
    asyncWrite.DestinationAddress.IA_Destination_Offset.Off_Low = 0;
    asyncWrite.nNumberOfBytesToWrite = sizeof(ULONG);
    asyncWrite.nBlockSize = 0;
    asyncWrite.fulFlags = 0;
    asyncWrite.ulGeneration = 0;

    if (DialogBoxParam( (HINSTANCE) GetWindowLongPtr(hWnd, GWLP_HINSTANCE),
                        "AsyncWrite",
                        hWnd,
                        AsyncWriteDlgProc,
                        (LPARAM)&asyncWrite
                        )) {

        dwRet = AsyncWrite( hWnd,
                            szDeviceName,
                            &asyncWrite,
                            TRUE
                            );
    }

    TRACE(TL_TRACE, (hWnd, "Exit w1394_AsyncWrite\r\n"));
    return;
} // w1394_AsyncWrite

INT_PTR CALLBACK
AsyncLockDlgProc(
    HWND        hDlg,
    UINT        uMsg,
    WPARAM      wParam,
    LPARAM      lParam
    )
{
    static PASYNC_LOCK      pAsyncLock;
    static CHAR             tmpBuff[STRING_SIZE];

    switch (uMsg) {

        case WM_INITDIALOG:

            pAsyncLock = (PASYNC_LOCK)lParam;

            if (pAsyncLock->bRawMode)
                CheckDlgButton( hDlg, IDC_ASYNC_LOCK_USE_BUS_NODE_NUMBER, BST_CHECKED);

            _ultoa(pAsyncLock->DestinationAddress.IA_Destination_ID.NA_Bus_Number, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_LOCK_BUS_NUMBER, tmpBuff);

            _ultoa(pAsyncLock->DestinationAddress.IA_Destination_ID.NA_Node_Number, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_LOCK_NODE_NUMBER, tmpBuff);

            _ultoa(pAsyncLock->DestinationAddress.IA_Destination_Offset.Off_High, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_LOCK_OFFSET_HIGH, tmpBuff);

            _ultoa(pAsyncLock->DestinationAddress.IA_Destination_Offset.Off_Low, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_LOCK_OFFSET_LOW, tmpBuff);

            CheckRadioButton( hDlg,
                              IDC_ASYNC_LOCK_32BIT,
                              IDC_ASYNC_LOCK_64BIT,
                              IDC_ASYNC_LOCK_32BIT
                              );

            _ultoa(pAsyncLock->Arguments[0], tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_LOCK_ARGUMENT1, tmpBuff);

            _ultoa(pAsyncLock->Arguments[1], tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_LOCK_ARGUMENT2, tmpBuff);

            _ultoa(pAsyncLock->DataValues[0], tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_LOCK_DATA1, tmpBuff);

            _ultoa(pAsyncLock->DataValues[1], tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_LOCK_DATA2, tmpBuff);

            if (pAsyncLock->bGetGeneration)
                CheckDlgButton( hDlg, IDC_ASYNC_LOCK_GET_GENERATION, BST_CHECKED);

            _ultoa(pAsyncLock->ulGeneration, tmpBuff, 16);