whyt1_diag.c

/*** *** *** *** *** *** *** *** *** *** *** *** * File: whyt1_lib.c * * Library for accessing W

/************************************************************************
*  File: whyt1_diag.c
*
*  Sample user-mode diagnostics application for accessing WHYT1
*  devices using WinDriver's API.
*  Code was generated by DriverWizard v9.01.
*
*  Copyright (c) 2007 Jungo Ltd.  http://www.jungo.com
*************************************************************************/

#include <stdio.h>
#include "wdc_lib.h"
#include "utils.h"
#include "status_strings.h"
#include "samples/shared/diag_lib.h"
#include "samples/shared/wdc_diag_lib.h"
#include "samples/shared/pci_regs.h"
#include "whyt1_lib.h"

/*************************************************************
  General definitions
 *************************************************************/
/* Error messages display */
#define WHYT1_ERR printf

/*************************************************************
  Global variables
 *************************************************************/
/* User's input command */
static CHAR gsInput[256];

/* --------------------------------------------------
    WHYT1 configuration registers information
   -------------------------------------------------- */
/* Configuration registers information array */
const WDC_REG gWHYT1_CfgRegs[] = {
    { WDC_AD_CFG_SPACE, PCI_VID, WDC_SIZE_16, WDC_READ_WRITE, "VID", "Vendor ID" },
    { WDC_AD_CFG_SPACE, PCI_DID, WDC_SIZE_16, WDC_READ_WRITE, "DID", "Device ID" },
    { WDC_AD_CFG_SPACE, PCI_CR, WDC_SIZE_16, WDC_READ_WRITE, "CMD", "Command" },
    { WDC_AD_CFG_SPACE, PCI_SR, WDC_SIZE_16, WDC_READ_WRITE, "STS", "Status" },
    { WDC_AD_CFG_SPACE, PCI_REV, WDC_SIZE_32, WDC_READ_WRITE, "RID_CLCD", "Revision ID & Class Code" },
    { WDC_AD_CFG_SPACE, PCI_CCSC, WDC_SIZE_8, WDC_READ_WRITE, "SCC", "Sub Class Code" },
    { WDC_AD_CFG_SPACE, PCI_CCBC, WDC_SIZE_8, WDC_READ_WRITE, "BCC", "Base Class Code" },
    { WDC_AD_CFG_SPACE, PCI_CLSR, WDC_SIZE_8, WDC_READ_WRITE, "CALN", "Cache Line Size" },
    { WDC_AD_CFG_SPACE, PCI_LTR, WDC_SIZE_8, WDC_READ_WRITE, "LAT", "Latency Timer" },
    { WDC_AD_CFG_SPACE, PCI_HDR, WDC_SIZE_8, WDC_READ_WRITE, "HDR", "Header Type" },
    { WDC_AD_CFG_SPACE, PCI_BISTR, WDC_SIZE_8, WDC_READ_WRITE, "BIST", "Built-in Self Test" },
    { WDC_AD_CFG_SPACE, PCI_BAR0, WDC_SIZE_32, WDC_READ_WRITE, "BADDR0", "Base Address 0" },
    { WDC_AD_CFG_SPACE, PCI_BAR1, WDC_SIZE_32, WDC_READ_WRITE, "BADDR1", "Base Address 1" },
    { WDC_AD_CFG_SPACE, PCI_BAR2, WDC_SIZE_32, WDC_READ_WRITE, "BADDR2", "Base Address 2" },
    { WDC_AD_CFG_SPACE, PCI_BAR3, WDC_SIZE_32, WDC_READ_WRITE, "BADDR3", "Base Address 3" },
    { WDC_AD_CFG_SPACE, PCI_BAR4, WDC_SIZE_32, WDC_READ_WRITE, "BADDR4", "Base Address 4" },
    { WDC_AD_CFG_SPACE, PCI_BAR5, WDC_SIZE_32, WDC_READ_WRITE, "BADDR5", "Base Address 5" },
    { WDC_AD_CFG_SPACE, PCI_CIS, WDC_SIZE_32, WDC_READ_WRITE, "CIS", "CardBus CIS Pointer" },
    { WDC_AD_CFG_SPACE, PCI_SVID, WDC_SIZE_16, WDC_READ_WRITE, "SVID", "Sub-system Vendor ID" },
    { WDC_AD_CFG_SPACE, PCI_SDID, WDC_SIZE_16, WDC_READ_WRITE, "SDID", "Sub-system Device ID" },
    { WDC_AD_CFG_SPACE, PCI_EROM, WDC_SIZE_32, WDC_READ_WRITE, "EROM", "Expansion ROM Base Address" },
    { WDC_AD_CFG_SPACE, PCI_CAP, WDC_SIZE_8, WDC_READ_WRITE, "NEW_CAP", "New Capabilities Pointer" },
    { WDC_AD_CFG_SPACE, PCI_ILR, WDC_SIZE_32, WDC_READ_WRITE, "INTLN", "Interrupt Line" },
    { WDC_AD_CFG_SPACE, PCI_IPR, WDC_SIZE_32, WDC_READ_WRITE, "INTPIN", "Interrupt Pin" },
    { WDC_AD_CFG_SPACE, PCI_MGR, WDC_SIZE_32, WDC_READ_WRITE, "MINGNT", "Minimum Required Burst Period" },
    { WDC_AD_CFG_SPACE, PCI_MLR, WDC_SIZE_32, WDC_READ_WRITE, "MAXLAT", "Maximum Latency" },
    };
#define WHYT1_CFG_REGS_NUM sizeof(gWHYT1_CfgRegs) / sizeof(WDC_REG)
/* TODO: For read-only or write-only registers, change the direction field of
         the relevant registers in gWHYT1_CfgRegs to WDC_READ or WDC_WRITE. */
/* NOTE: You can define additional configuration registers in gWHYT1_CfgRegs. */
const WDC_REG *gpWHYT1_CfgRegs = gWHYT1_CfgRegs;

/* -----------------------------------------------
    WHYT1 run-time registers information
   ----------------------------------------------- */
/* Run-time registers information array */
const WDC_REG gWHYT1_Regs[] = {
    { WHYT1_I2CDAT11_SPACE, WHYT1_I2CDAT11_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "I2CDAT11", "" },
    { WHYT1_I2CDAT10_SPACE, WHYT1_I2CDAT10_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "I2CDAT10", "" },
    { WHYT1_I2CDAT9_SPACE, WHYT1_I2CDAT9_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "I2CDAT9", "" },
    { WHYT1_I2CDAT8_SPACE, WHYT1_I2CDAT8_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "I2CDAT8", "" },
    { WHYT1_I2CDAT7_SPACE, WHYT1_I2CDAT7_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "I2CDAT7", "" },
    { WHYT1_I2CDAT6_SPACE, WHYT1_I2CDAT6_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "I2CDAT6", "" },
    { WHYT1_I2CDAT5_SPACE, WHYT1_I2CDAT5_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "I2CDAT5", "" },
    { WHYT1_I2CDAT4_SPACE, WHYT1_I2CDAT4_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "I2CDAT4", "" },
    { WHYT1_I2CDAT3_SPACE, WHYT1_I2CDAT3_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "I2CDAT3", "" },
    { WHYT1_I2CDAT2_SPACE, WHYT1_I2CDAT2_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "I2CDAT2", "" },
    { WHYT1_I2CDAT1_SPACE, WHYT1_I2CDAT1_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "I2CDAT1", "" },
    { WHYT1_I2CDAT0_SPACE, WHYT1_I2CDAT0_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "I2CDAT0", "" },
    { WHYT1_I2CSTS_SPACE, WHYT1_I2CSTS_OFFSET, WDC_SIZE_8, WDC_READ, "I2CSTS", "" },
    { WHYT1_I2CCTR_SPACE, WHYT1_I2CCTR_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "I2CCTR", "" },
    { WHYT1_IRCODE_SPACE, WHYT1_IRCODE_OFFSET, WDC_SIZE_32, WDC_READ_WRITE, "IRCODE", "" },
    { WHYT1_IRCTR_SPACE, WHYT1_IRCTR_OFFSET, WDC_SIZE_32, WDC_READ_WRITE, "IRCTR", "" },
    { WHYT1_EVEN_SPACE, WHYT1_EVEN_OFFSET, WDC_SIZE_32, WDC_READ_WRITE, "EVEN", "" },
    { WHYT1_ODD_SPACE, WHYT1_ODD_OFFSET, WDC_SIZE_32, WDC_READ_WRITE, "ODD", "" },
    { WHYT1_INTCNT_SPACE, WHYT1_INTCNT_OFFSET, WDC_SIZE_32, WDC_READ_WRITE, "INTCNT", "" },
    { WHYT1_WRP_SPACE, WHYT1_WRP_OFFSET, WDC_SIZE_32, WDC_READ, "WRP", "" },
    { WHYT1_RLEN_SPACE, WHYT1_RLEN_OFFSET, WDC_SIZE_32, WDC_READ_WRITE, "RLEN", "" },
    { WHYT1_STADR_SPACE, WHYT1_STADR_OFFSET, WDC_SIZE_32, WDC_READ_WRITE, "STADR", "" },
    { WHYT1_HOST_AD_SPACE, WHYT1_HOST_AD_OFFSET, WDC_SIZE_32, WDC_READ_WRITE, "HOST_AD", "" },
    { WHYT1_HOST_CTR_SPACE, WHYT1_HOST_CTR_OFFSET, WDC_SIZE_32, WDC_READ_WRITE, "HOST_CTR", "" },
    { WHYT1_CWSEL_SPACE, WHYT1_CWSEL_OFFSET, WDC_SIZE_32, WDC_READ_WRITE, "CWSEL", "" },
    { WHYT1_PIDN_SPACE, WHYT1_PIDN_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "PIDN", "" },
    { WHYT1_GIPOCTR_SPACE, WHYT1_GIPOCTR_OFFSET, WDC_SIZE_32, WDC_READ_WRITE, "GIPOCTR", "" },
    { WHYT1_GIPOVAL_SPACE, WHYT1_GIPOVAL_OFFSET, WDC_SIZE_32, WDC_READ_WRITE, "GIPOVAL", "" },
    { WHYT1_IRMODE_SPACE, WHYT1_IRMODE_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "IRMODE", "" },
    { WHYT1_SYSTEMCODE_SPACE, WHYT1_SYSTEMCODE_OFFSET, WDC_SIZE_16, WDC_READ_WRITE, "SYSTEMCODE", "" },
    { WHYT1_PID_SPACE, WHYT1_PID_OFFSET, WDC_SIZE_16, WDC_READ_WRITE, "PID", "" },
    { WHYT1_INTMAK_SPACE, WHYT1_INTMAK_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "INTMAK", "" },
    { WHYT1_INSTS_SPACE, WHYT1_INSTS_OFFSET, WDC_SIZE_8, WDC_READ, "INSTS", "" },
    { WHYT1_RST_SPACE, WHYT1_RST_OFFSET, WDC_SIZE_8, WDC_WRITE, "RST", "" },
    { WHYT1_CR_SPACE, WHYT1_CR_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "CR", "" },
    { WHYT1_DTALENTH_SPACE, WHYT1_DTALENTH_OFFSET, WDC_SIZE_8, WDC_READ_WRITE, "DTALENTH", "" },
    { WHYT1_TSCTR_SPACE, WHYT1_TSCTR_OFFSET, WDC_SIZE_16, WDC_READ_WRITE, "TSCTR", "" },
    };
const WDC_REG *gpWHYT1_Regs = gWHYT1_Regs;
#define WHYT1_REGS_NUM 37

/*************************************************************
  Static functions prototypes
 *************************************************************/
/* -----------------------------------------------
    Main diagnostics menu
   ----------------------------------------------- */
static void MenuMain(WDC_DEVICE_HANDLE *phDev);

/* -----------------------------------------------
    Device find, open and close
   ----------------------------------------------- */
static WDC_DEVICE_HANDLE DeviceFindAndOpen(DWORD dwVendorId, DWORD dwDeviceId);
static BOOL DeviceFind(DWORD dwVendorId, DWORD dwDeviceId, WD_PCI_SLOT *pSlot);
static WDC_DEVICE_HANDLE DeviceOpen(const WD_PCI_SLOT *pSlot);
static void DeviceClose(WDC_DEVICE_HANDLE hDev);

/* -----------------------------------------------
    Read/write memory and I/O addresses
   ----------------------------------------------- */
static void MenuReadWriteAddr(WDC_DEVICE_HANDLE hDev);
static void SetAddrSpace(WDC_DEVICE_HANDLE hDev, PDWORD pdwAddrSpace);

/* -----------------------------------------------
    Read/write the configuration space
   ----------------------------------------------- */
static void MenuReadWriteCfgSpace(WDC_DEVICE_HANDLE hDev);

/* -----------------------------------------------
    Read/write the run-time registers
   ----------------------------------------------- */
static void MenuReadWriteRegs(WDC_DEVICE_HANDLE hDev);

/* -----------------------------------------------
    Interrupt handling
   ----------------------------------------------- */
static void MenuInterrupts(WDC_DEVICE_HANDLE hDev);
static void DiagIntHandler(WDC_DEVICE_HANDLE hDev, WHYT1_INT_RESULT *pIntResult);

/* ----------------------------------------------------
    Plug-and-play and power management events handling
   ---------------------------------------------------- */
static void MenuEvents(WDC_DEVICE_HANDLE hDev);
static void DiagEventHandler(WDC_DEVICE_HANDLE hDev, DWORD dwAction);

/*************************************************************
  Functions implementation
 *************************************************************/
int main(void)
{
    WDC_DEVICE_HANDLE hDev = NULL;
    DWORD dwStatus;

    printf("\n");
    printf("WHYT1 diagnostic utility.\n");
    printf("Application accesses hardware using " WD_PROD_NAME ".\n");

    /* Initialize the WHYT1 library */
    dwStatus = WHYT1_LibInit();
    if (WD_STATUS_SUCCESS != dwStatus)
    {
        WHYT1_ERR("whyt1_diag: Failed to initialize the WHYT1 library: %s",
            WHYT1_GetLastErr());
        return dwStatus;
    }

    /* Find and open a WHYT1 device (by default ID) */
    if (WHYT1_DEFAULT_VENDOR_ID)
        hDev = DeviceFindAndOpen(WHYT1_DEFAULT_VENDOR_ID, WHYT1_DEFAULT_DEVICE_ID);

    /* Display main diagnostics menu for communicating with the device */
    MenuMain(&hDev);

    /* Perform necessary cleanup before exiting the program */
    if (hDev)
        DeviceClose(hDev);
 
    dwStatus = WHYT1_LibUninit();
    if (WD_STATUS_SUCCESS != dwStatus)
        WHYT1_ERR("whyt1_diag: Failed to uninit the WHYT1 library: %s", WHYT1_GetLastErr());
    
    return dwStatus;
}

/* -----------------------------------------------
    Main diagnostics menu
   ----------------------------------------------- */
/* Main menu options */
enum {
    MENU_MAIN_SCAN_PCI_BUS = 1,
    MENU_MAIN_FIND_AND_OPEN,
    MENU_MAIN_RW_ADDR,
    MENU_MAIN_RW_CFG_SPACE,
    MENU_MAIN_RW_REGS,
    MENU_MAIN_ENABLE_DISABLE_INT,
    MENU_MAIN_EVENTS,
    MENU_MAIN_EXIT = DIAG_EXIT_MENU,
};

/* Main diagnostics menu */
static void MenuMain(WDC_DEVICE_HANDLE *phDev)
{
    DWORD option;
    
    do
    {
        printf("\n");
        printf("WHYT1 main menu\n");
        printf("--------------\n");
        printf("%d. Scan PCI bus\n", MENU_MAIN_SCAN_PCI_BUS);
        printf("%d. Find and open a WHYT1 device\n", MENU_MAIN_FIND_AND_OPEN);
        if (*phDev)
        {
            printf("%d. Read/write memory and IO addresses on the device\n",
                MENU_MAIN_RW_ADDR);
            printf("%d. Read/write the device's configuration space\n",
                MENU_MAIN_RW_CFG_SPACE);
            if (WHYT1_REGS_NUM)
            {
                printf("%d. Read/write the run-time registers\n",
                    MENU_MAIN_RW_REGS);
            }
            printf("%d. Enable/disable the device's interrupts\n",
                MENU_MAIN_ENABLE_DISABLE_INT);
            printf("%d. Register/unregister plug-and-play and power management "
                "events\n", MENU_MAIN_EVENTS);
        }
        printf("%d. Exit\n", MENU_MAIN_EXIT);
        
        if (DIAG_INPUT_FAIL == DIAG_GetMenuOption(&option,
            *phDev ? MENU_MAIN_EVENTS : MENU_MAIN_FIND_AND_OPEN))
        {
            continue;
        }

        switch (option)
        {
        case MENU_MAIN_EXIT: /* Exit menu */
            break;
        case MENU_MAIN_SCAN_PCI_BUS: /* Scan PCI bus */
            WDC_DIAG_PciDevicesInfoPrintAll(FALSE);
            break;
        case MENU_MAIN_FIND_AND_OPEN: /* Find and open a WHYT1 device */
            if (*phDev)
                DeviceClose(*phDev);
            *phDev = DeviceFindAndOpen(0, 0);
            break;
        case MENU_MAIN_RW_ADDR: /* Read/write memory and I/O addresses */
            MenuReadWriteAddr(*phDev);
            break;
        case MENU_MAIN_RW_CFG_SPACE: /* Read/Write the WHYT1 configuration space */
            MenuReadWriteCfgSpace(*phDev);
            break;
        case MENU_MAIN_RW_REGS: /* Read/write the run-time registers */
            if (WHYT1_REGS_NUM)
                MenuReadWriteRegs(*phDev);
            else
                printf("Invalid selection\n");
            break;
        case MENU_MAIN_ENABLE_DISABLE_INT: /* Enable/disable interrupts */
            MenuInterrupts(*phDev);
            break;
        case MENU_MAIN_EVENTS: /* Register/unregister plug-and-play and power management events */
            MenuEvents(*phDev);
            break;
        }
    } while (MENU_MAIN_EXIT != option);
}

/* -----------------------------------------------
    Device find, open and close
   ----------------------------------------------- */
/* Find and open a WHYT1 device */
static WDC_DEVICE_HANDLE DeviceFindAndOpen(DWORD dwVendorId, DWORD dwDeviceId)
{
    WD_PCI_SLOT slot;
    
    if (!DeviceFind(dwVendorId, dwDeviceId, &slot))
        return NULL;