example_diag.c

关于WinDriver的自动生成的PCI驱动源代码

        printf("--------------------------------------------\n");
        printf("%d. Read from an offset\n", MENU_RW_CFG_SPACE_READ_OFFSET);
        printf("%d. Write to an offset\n", MENU_RW_CFG_SPACE_WRITE_OFFSET);
        if (EXAMPLE_CFG_REGS_NUM)
        {
            printf("%d. Read all configuration registers defined for the device (see list above)\n",
                MENU_RW_CFG_SPACE_READ_ALL_REGS);
            printf("%d. Read from a named register\n", MENU_RW_CFG_SPACE_READ_REG);
            printf("%d. Write to a named register\n", MENU_RW_CFG_SPACE_WRITE_REG);
        }
        printf("%d. Exit menu\n", MENU_RW_CFG_SPACE_EXIT);
        printf("\n");

        if (DIAG_INPUT_FAIL == DIAG_GetMenuOption(&option,
            EXAMPLE_CFG_REGS_NUM ? MENU_RW_CFG_SPACE_WRITE_REG :
            MENU_RW_CFG_SPACE_WRITE_OFFSET))
        {
            continue;
        }
        
        switch (option)
        {
        case MENU_RW_CFG_SPACE_EXIT: //* Exit menu *
            break;
        case MENU_RW_CFG_SPACE_READ_OFFSET: //* Read from a configuration space offset *
            WDC_DIAG_ReadWriteBlock(hDev, WDC_READ, WDC_AD_CFG_SPACE);
            break;
        case MENU_RW_CFG_SPACE_WRITE_OFFSET: //* Write to a configuration space offset *
            WDC_DIAG_ReadWriteBlock(hDev, WDC_WRITE, WDC_AD_CFG_SPACE);
            break;
        case MENU_RW_CFG_SPACE_READ_ALL_REGS:
            WDC_DIAG_ReadRegsAll(hDev, gpEXAMPLE_CfgRegs, EXAMPLE_CFG_REGS_NUM, TRUE);
            break;
        case MENU_RW_CFG_SPACE_READ_REG:  //* Read from a configuration register *
            WDC_DIAG_ReadWriteReg(hDev, gpEXAMPLE_CfgRegs, EXAMPLE_CFG_REGS_NUM, WDC_READ, TRUE);
            break;
        case MENU_RW_CFG_SPACE_WRITE_REG: //* Write to a configuration register *
            WDC_DIAG_ReadWriteReg(hDev, gpEXAMPLE_CfgRegs, EXAMPLE_CFG_REGS_NUM, WDC_WRITE, TRUE);
            break;
        }
    } while (MENU_RW_CFG_SPACE_EXIT != option);
}

//* -----------------------------------------------
    Read/write the run-time registers
   ----------------------------------------------- *
//* Read/write the run-time registers menu options *
enum {
    MENU_RW_REGS_READ_ALL = 1,
    MENU_RW_REGS_READ_REG,
    MENU_RW_REGS_WRITE_REG,
    MENU_RW_REGS_EXIT = DIAG_EXIT_MENU,
};

//* Display read/write run-time registers menu *
static void MenuReadWriteRegs(WDC_DEVICE_HANDLE hDev)
{
    DWORD option;
    
    if (!EXAMPLE_REGS_NUM)
    {
        printf("There are currently no pre-defined run-time registers\n");
        return;
    }
  
    do {
       / /* Display pre-defined registers' information *
        printf("\n");
        printf("EXAMPLE run-time registers:\n");
        printf("--------------------------\n");   
        WDC_DIAG_RegsInfoPrint(gpEXAMPLE_Regs, EXAMPLE_REGS_NUM, WDC_DIAG_REG_PRINT_ALL);

        printf("\n");
        printf("Read/write the EXAMPLE run-time registers\n");
        printf("-----------------------------------------\n");
        printf("%d. Read all run-time registers defined for the device (see list above)\n",
            MENU_RW_REGS_READ_ALL);
        printf("%d. Read from a specific register\n", MENU_RW_REGS_READ_REG);
        printf("%d. Write to a specific register\n", MENU_RW_REGS_WRITE_REG);
        printf("%d. Exit menu\n", MENU_RW_REGS_EXIT);
        printf("\n");

        if (DIAG_INPUT_FAIL == DIAG_GetMenuOption(&option,
            MENU_RW_REGS_WRITE_REG))
        {
            continue;
        }

        switch (option)
        {
        case MENU_RW_REGS_EXIT: //* Exit menu *
            break;
        case MENU_RW_REGS_READ_ALL:
            WDC_DIAG_ReadRegsAll(hDev, gpEXAMPLE_Regs, EXAMPLE_REGS_NUM, FALSE);
            break;
        case MENU_RW_REGS_READ_REG:  //** Read from a register 
            WDC_DIAG_ReadWriteReg(hDev, gpEXAMPLE_Regs, EXAMPLE_REGS_NUM, WDC_READ, FALSE);
            break;
        case MENU_RW_REGS_WRITE_REG: //* Write to a register *
            WDC_DIAG_ReadWriteReg(hDev, gpEXAMPLE_Regs, EXAMPLE_REGS_NUM, WDC_WRITE, FALSE);
            break;
        }
    } while (MENU_RW_REGS_EXIT != option);
}

//* -----------------------------------------------
    Interrupt handling
   ----------------------------------------------- *
//* Interrupts menu options *
enum {
    MENU_INT_ENABLE_DISABLE = 1,
    MENU_INT_EXIT = DIAG_EXIT_MENU,
};

//* Enable/Disable interrupts menu *
static void MenuInterrupts(WDC_DEVICE_HANDLE hDev)
{
    DWORD option, dwIntOptions;
    BOOL fIntEnable, fIsMsi;

    dwIntOptions = WDC_GET_INT_OPTIONS(hDev);
    fIsMsi = WDC_INT_IS_MSI(dwIntOptions);
    do
    {
        fIntEnable = !EXAMPLE_IntIsEnabled(hDev);

        printf("\n");
        printf("Interrupts\n");
        printf("-----------\n");
        printf("%d. %s interrupts\n", MENU_INT_ENABLE_DISABLE,
            fIntEnable ? "Enable" : "Disable");
        printf("%d. Exit menu\n", MENU_INT_EXIT);
        printf("\n");

        if (DIAG_INPUT_FAIL == DIAG_GetMenuOption(&option,
            MENU_RW_ADDR_WRITE))
        {
            continue;
        }

        switch (option)
        {
        case MENU_INT_EXIT: //* Exit menu *
            break;
        case MENU_INT_ENABLE_DISABLE: //* Enable/disable interrupts *
            if (fIntEnable)
            {
                DWORD dwStatus = EXAMPLE_IntEnable(hDev, DiagIntHandler);

                if (WD_STATUS_SUCCESS == dwStatus)
                    printf("Interrupts enabled\n");
                else
                {
                    EXAMPLE_ERR("Failed enabling interrupts. Error 0x%lx - %s\n",
                       dwStatus, Stat2Str(dwStatus));
                }
            }
            else
            {
                if (WD_STATUS_SUCCESS == EXAMPLE_IntDisable(hDev))
                    printf("Interrupts disabled\n");
                else
                    EXAMPLE_ERR("Failed disabling interrupts: %s", EXAMPLE_GetLastErr());
            }
            break;
        }
    } while (MENU_INT_EXIT != option);
}

//* Diagnostics interrupt handler routine *
static void DiagIntHandler(WDC_DEVICE_HANDLE hDev, EXAMPLE_INT_RESULT *pIntResult)
{
    //* TODO: You can modify this function in order to implement your own diagnostics interrupt handler routine *

    printf("Got interrupt number %ld\n", pIntResult->dwCounter);
    printf("Interrupt Type: %s\n",
        WDC_DIAG_IntTypeDescriptionGet(pIntResult->dwEnabledIntType));
    if (WDC_INT_IS_MSI(pIntResult->dwEnabledIntType))
        printf("Message Data: 0x%lx\n", pIntResult->dwLastMessage);
}

//* ----------------------------------------------------
    Plug-and-play and power management events handling
   ---------------------------------------------------- *
//* Events menu options *
enum {
    MENU_EVENTS_REGISTER_UNREGISTER = 1,
    MENU_EVENTS_EXIT = DIAG_EXIT_MENU,
};

//* Register/unregister Plug-and-play and power management events *
static void MenuEvents(WDC_DEVICE_HANDLE hDev)
{
    DWORD option;
    BOOL fRegister;

    do
    {
        fRegister = !EXAMPLE_EventIsRegistered(hDev);
        
        printf("\n");
        printf("Plug-and-play and power management events\n");
        printf("------------------------------------------\n");
        printf("%d. %s events\n", MENU_EVENTS_REGISTER_UNREGISTER,
            fRegister ? "Register" : "Unregister");
        printf("%d. Exit menu\n", MENU_EVENTS_EXIT);
        printf("\n");
        
        if (DIAG_INPUT_FAIL == DIAG_GetMenuOption(&option,
            MENU_EVENTS_REGISTER_UNREGISTER))
        {
            continue;
        }

        switch (option)
        {
        case MENU_EVENTS_EXIT: //* Exit menu *
            break;
        case MENU_EVENTS_REGISTER_UNREGISTER: //* Register/unregister events *
            if (fRegister)
            {
                if (WD_STATUS_SUCCESS == EXAMPLE_EventRegister(hDev, DiagEventHandler))
                    printf("Events registered\n");
                else
                    EXAMPLE_ERR("Failed to register events. Last error:\n%s", EXAMPLE_GetLastErr());
            }
            else
            {
                if (WD_STATUS_SUCCESS == EXAMPLE_EventUnregister(hDev))
                    printf("Events unregistered\n");
                else
                    EXAMPLE_ERR("Failed to unregister events. Last Error:\n%s", EXAMPLE_GetLastErr());
            }
            break;
        }
    } while (MENU_EVENTS_EXIT != option);
}

//* Plug-and-play and power management events handler routine *
static void DiagEventHandler(WDC_DEVICE_HANDLE hDev, DWORD dwAction)
{
    //* TODO: You can modify this function in order to implement your own  diagnostics events handler routine *

    printf("\nReceived event notification (device handle 0x%p): ", hDev);
    switch (dwAction)
    {
    case WD_INSERT:
        printf("WD_INSERT\n");
        break;
    case WD_REMOVE:
        printf("WD_REMOVE\n");
        break;
    case WD_POWER_CHANGED_D0:
        printf("WD_POWER_CHANGED_D0\n");
        break;
    case WD_POWER_CHANGED_D1:
        printf("WD_POWER_CHANGED_D1\n");
        break;
    case WD_POWER_CHANGED_D2:
        printf("WD_POWER_CHANGED_D2\n");
        break;
    case WD_POWER_CHANGED_D3:
        printf("WD_POWER_CHANGED_D3\n");
        break;
    case WD_POWER_SYSTEM_WORKING:
        printf("WD_POWER_SYSTEM_WORKING\n");
        break;
    case WD_POWER_SYSTEM_SLEEPING1:
        printf("WD_POWER_SYSTEM_SLEEPING1\n");
        break;
    case WD_POWER_SYSTEM_SLEEPING2:
        printf("WD_POWER_SYSTEM_SLEEPING2\n");
        break;
    case WD_POWER_SYSTEM_SLEEPING3:
        printf("WD_POWER_SYSTEM_SLEEPING3\n");
        break;
    case WD_POWER_SYSTEM_HIBERNATE:
        printf("WD_POWER_SYSTEM_HIBERNATE\n");
        break;
    case WD_POWER_SYSTEM_SHUTDOWN:
        printf("WD_POWER_SYSTEM_SHUTDOWN\n");
        break;
    default:
        printf("0x%lx\n", dwAction);
        break;
    }
}

*/