async.c

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

            SetDlgItemText(hDlg, IDC_ASYNC_LOOP_ITERATIONS, tmpBuff);

            if (pLoopbackParams->ulLoopFlag & ASYNC_LOOPBACK_READ)
                CheckDlgButton(hDlg, IDC_ASYNC_LOOP_READ, BST_CHECKED);

            if (pLoopbackParams->ulLoopFlag & ASYNC_LOOPBACK_WRITE)
                CheckDlgButton(hDlg, IDC_ASYNC_LOOP_WRITE, BST_CHECKED);

            if (pLoopbackParams->ulLoopFlag & ASYNC_LOOPBACK_LOCK)
                CheckDlgButton(hDlg, IDC_ASYNC_LOOP_LOCK, BST_CHECKED);

            if (pLoopbackParams->ulLoopFlag & ASYNC_LOOPBACK_RANDOM_LENGTH)
                CheckDlgButton(hDlg, IDC_ASYNC_LOOP_RANDOM_SIZE, BST_CHECKED);

            return(TRUE); // WM_INITDIALOG

        case WM_COMMAND:

            switch (LOWORD(wParam)) {

                case IDOK:

                    GetDlgItemText(hDlg, IDC_ASYNC_LOOP_OFFSET_HIGH, tmpBuff, STRING_SIZE);
                    pLoopbackParams->AddressOffset.Off_High = (USHORT)strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_LOOP_OFFSET_LOW, tmpBuff, STRING_SIZE);
                    pLoopbackParams->AddressOffset.Off_Low = strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_LOOP_MAX_BYTES, tmpBuff, STRING_SIZE);
                    pLoopbackParams->nMaxBytes = strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_LOOP_ITERATIONS, tmpBuff, STRING_SIZE);
                    pLoopbackParams->nIterations = strtoul(tmpBuff, NULL, 16);

                    pLoopbackParams->ulLoopFlag = 0;
                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_LOOP_READ))
                        pLoopbackParams->ulLoopFlag |= ASYNC_LOOPBACK_READ;

                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_LOOP_WRITE))
                        pLoopbackParams->ulLoopFlag |= ASYNC_LOOPBACK_WRITE;

                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_LOOP_LOCK))
                        pLoopbackParams->ulLoopFlag |= ASYNC_LOOPBACK_LOCK;

                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_LOOP_RANDOM_SIZE))
                        pLoopbackParams->ulLoopFlag |= ASYNC_LOOPBACK_RANDOM_LENGTH;

                    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);
} // AsyncLoopbackDlgProc

void
w1394_AsyncStartLoopback(
    HWND                    hWnd,
    PSTR                    szDeviceName,
    PASYNC_LOOPBACK_PARAMS  asyncLoopbackParams
    )
{
    DWORD       dwRet;
    ULONG       generationCount;

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

    asyncLoopbackParams->szDeviceName = szDeviceName;
    asyncLoopbackParams->hWnd = hWnd;
    asyncLoopbackParams->bKill = FALSE;

    asyncLoopbackParams->ulLoopFlag = ASYNC_LOOPBACK_READ | ASYNC_LOOPBACK_WRITE | ASYNC_LOOPBACK_RANDOM_LENGTH;
    asyncLoopbackParams->nIterations = 0;

    asyncLoopbackParams->AddressOffset.Off_High = 1;
    asyncLoopbackParams->AddressOffset.Off_Low = 0;

    asyncLoopbackParams->nMaxBytes = 0x200;

    if (DialogBoxParam( (HINSTANCE) GetWindowLongPtr(hWnd, GWLP_HINSTANCE),
                        "AsyncLoopback",
                        hWnd,
                        AsyncLoopbackDlgProc,
                        (LPARAM)asyncLoopbackParams
                        )) {

        GetLocalTime(&AsyncStartTime);

        AsyncStartLoopback( hWnd,
                            szDeviceName,
                            asyncLoopbackParams
                            );

        asyncLoopbackStarted = TRUE;
    }

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

void
w1394_AsyncStopLoopback(
    HWND                    hWnd,
    PASYNC_LOOPBACK_PARAMS  asyncLoopbackParams
    )
{
    TRACE(TL_TRACE, (hWnd, "Enter w1394_AsyncStopLoopback\r\n"));

#ifdef LOGGER
    Logger_WriteTestLog( "1394",
                         "Async Loopback",
                         NULL,
                         asyncLoopbackParams->ulPass,
                         asyncLoopbackParams->ulFail,
                         &AsyncStartTime,
                         NULL,
                         NULL
                         );
#endif

    AsyncStopLoopback( asyncLoopbackParams );

    asyncLoopbackStarted = FALSE;

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

INT_PTR CALLBACK
AsyncStreamLoopbackDlgProc(
    HWND        hDlg,
    UINT        uMsg,
    WPARAM      wParam,
    LPARAM      lParam
    )
{
    static PASYNC_STREAM_LOOPBACK_PARAMS    pLoopbackParams;
    static CHAR                             tmpBuff[STRING_SIZE];

    switch (uMsg) {

        case WM_INITDIALOG:

            pLoopbackParams = (PASYNC_STREAM_LOOPBACK_PARAMS)lParam;

            _ultoa(pLoopbackParams->asyncStream.nChannel, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_STREAM_LOOP_CHANNEL, tmpBuff);

            _ultoa(pLoopbackParams->asyncStream.nNumberOfBytesToStream, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_STREAM_LOOP_BYTES_TO_STREAM, tmpBuff);

            _ultoa(pLoopbackParams->asyncStream.ulSynch, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_STREAM_LOOP_SYNCH, tmpBuff);

            _ultoa(pLoopbackParams->asyncStream.ulTag, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_STREAM_LOOP_TAG, tmpBuff);

            _ultoa(pLoopbackParams->nIterations, tmpBuff, 16);
            SetDlgItemText(hDlg, IDC_ASYNC_STREAM_LOOP_ITERATIONS, tmpBuff);

            if (pLoopbackParams->asyncStream.nSpeed == SPEED_FLAGS_FASTEST) {

                CheckRadioButton( hDlg,
                                  IDC_ASYNC_STREAM_LOOP_100MBPS,
                                  IDC_ASYNC_STREAM_LOOP_FASTEST,
                                  IDC_ASYNC_STREAM_LOOP_FASTEST
                                  );
            }
            else {

                CheckRadioButton( hDlg,
                                  IDC_ASYNC_STREAM_LOOP_100MBPS,
                                  IDC_ASYNC_STREAM_LOOP_FASTEST,
                                  pLoopbackParams->asyncStream.nSpeed + (IDC_ASYNC_STREAM_LOOP_100MBPS-1)
                                  );
            }
            return(TRUE); // WM_INITDIALOG

        case WM_COMMAND:

            switch (LOWORD(wParam)) {

                case IDOK:

                    GetDlgItemText(hDlg, IDC_ASYNC_STREAM_LOOP_CHANNEL, tmpBuff, STRING_SIZE);
                    pLoopbackParams->asyncStream.nChannel = strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_STREAM_LOOP_BYTES_TO_STREAM, tmpBuff, STRING_SIZE);
                    pLoopbackParams->asyncStream.nNumberOfBytesToStream = strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_STREAM_LOOP_SYNCH, tmpBuff, STRING_SIZE);
                    pLoopbackParams->asyncStream.ulSynch = strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_STREAM_LOOP_TAG, tmpBuff, STRING_SIZE);
                    pLoopbackParams->asyncStream.ulTag = strtoul(tmpBuff, NULL, 16);

                    GetDlgItemText(hDlg, IDC_ASYNC_STREAM_LOOP_ITERATIONS, tmpBuff, STRING_SIZE);
                    pLoopbackParams->nIterations = strtoul(tmpBuff, NULL, 16);

                    pLoopbackParams->asyncStream.nSpeed = 0;
                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_STREAM_LOOP_100MBPS))
                        pLoopbackParams->asyncStream.nSpeed = SPEED_FLAGS_100;

                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_STREAM_LOOP_200MBPS))
                        pLoopbackParams->asyncStream.nSpeed = SPEED_FLAGS_200;

                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_STREAM_LOOP_400MBPS))
                        pLoopbackParams->asyncStream.nSpeed = SPEED_FLAGS_400;

                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_STREAM_LOOP_1600MBPS))
                        pLoopbackParams->asyncStream.nSpeed = SPEED_FLAGS_1600;

                    if (IsDlgButtonChecked(hDlg, IDC_ASYNC_STREAM_LOOP_FASTEST))
                        pLoopbackParams->asyncStream.nSpeed = SPEED_FLAGS_FASTEST;

                    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);
} // AsyncStreamLoopbackDlgProc

void
w1394_AsyncStreamStartLoopback(
    HWND                            hWnd,
    PSTR                            szDeviceName,
    PASYNC_STREAM_LOOPBACK_PARAMS   streamLoopbackParams
    )
{
    DWORD       dwRet;

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

    streamLoopbackParams->szDeviceName = szDeviceName;
    streamLoopbackParams->hWnd = hWnd;
    streamLoopbackParams->bKill = FALSE;

    streamLoopbackParams->bAutoAlloc = TRUE;
    streamLoopbackParams->bAutoFill = TRUE;
    streamLoopbackParams->nIterations = 0;

    streamLoopbackParams->asyncStream.nNumberOfBytesToStream = 640;
    streamLoopbackParams->asyncStream.fulFlags = 0;
    streamLoopbackParams->asyncStream.ulTag = 0;
    streamLoopbackParams->asyncStream.nChannel = 0;
    streamLoopbackParams->asyncStream.ulSynch = 0;
    streamLoopbackParams->asyncStream.nSpeed = SPEED_FLAGS_200;

    if (DialogBoxParam( (HINSTANCE) GetWindowLongPtr(hWnd, GWLP_HINSTANCE),
                        "AsyncStreamLoopback",
                        hWnd,
                        AsyncStreamLoopbackDlgProc,
                        (LPARAM)streamLoopbackParams
                        )) {

        GetLocalTime(&StreamStartTime);

        AsyncStreamStartLoopback( hWnd,
                                  szDeviceName,
                                  streamLoopbackParams
                                  );

        streamLoopbackStarted = TRUE;
    }

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

void
w1394_AsyncStreamStopLoopback(
    HWND                            hWnd,
    PASYNC_STREAM_LOOPBACK_PARAMS   streamLoopbackParams
    )
{
    TRACE(TL_TRACE, (hWnd, "Enter w1394_AsyncStreamStopLoopback\r\n"));

#ifdef LOGGER
    Logger_WriteTestLog( "1394",
                         "Async Stream Loopback",
                         NULL,
                         streamLoopbackParams->ulPass,
                         streamLoopbackParams->ulFail,
                         &StreamStartTime,
                         NULL,
                         NULL
                         );
#endif

    AsyncStreamStopLoopback( streamLoopbackParams );

    streamLoopbackStarted = FALSE;

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