source: trunk/third/sysinfo/pci.c @ 12269

/*
 * Copyright (c) 1992-1998 Michael A. Cooper.
 * This software may be freely used and distributed provided it is not
 * sold for profit or used in part or in whole for commercial gain
 * without prior written agreement, and the author is credited
 * appropriately.
 */

#ifndef lint
static char *RCSid = "$Revision: 1.1.1.1 $";
#endif

/*
 * General PCI functions
 */

#include "defs.h"
#include "probe.h"

/*
 * Set what PCI Device info we can by looking things up in pci.cf
 */
extern void PCIsetDeviceInfo(Info)
     PCIinfo_t                 *Info;
{
    DevInfo_t                  *DevInfo = NULL;
    DevType_t                  *DevType = NULL;
    ClassType_t                *ClassType = NULL;
    Define_t                   *Define;
    static char                 Buff[256];
    static char                 Query[64];
    int                         Len;
    PCIid_t                     VendorID;
    PCIid_t                     DeviceID;

    /*
     * Ok for empty DeviceID
     */
    if (!Info || !Info->VendorID)
        return;

    VendorID = Info->VendorID;
    DeviceID = Info->DeviceID;
    if (Info->DevInfo)
        DevInfo = Info->DevInfo;
    else
        DevInfo = Info->DevInfo = NewDevInfo(NULL);

    /* See if we can find the Vendor */
    Define = DefGet("PCIvendor", NULL, VendorID);
    if (!Define) {
        /*
         * The VendorID is unknown so use the ID numbers.
         */
        SImsg(SIM_UNKN, "PCI Vendor=0x%04x Device=0x%04x", VendorID, DeviceID);
    } else {
        /*
         * We found the vendor
         */
        DevInfo->Vendor = Define->ValStr1;

        /* Now see if we can find a device from the vendor */
        (void) snprintf(Query, sizeof(Query), "PCIdevice0x%04x", VendorID);
        if (Define = DefGet(Query, NULL, DeviceID)) {
            /*
             * We found the Device!
             */
            DevInfo->Model = Define->ValStr1;

            if (Define->ValStr2)
                /*
                 * See if we can determine the DevType
                 */
                if (DevType = TypeGetByName(Define->ValStr2))
                    DevInfo->Type = DevType->Type;
            if (Define->ValStr3) {
                /*
                 * Now see if we can find the ClassType for this DevType 
                 */
                if (DevType) {
                    if (ClassType = ClassTypeGetByName(DevType->Type, 
                                                       Define->ValStr3))
                        DevInfo->ClassType = ClassType->Type;
                }
                if (!ClassType)
                    /* Couldn't find the class type so use the name we have */
                    DevInfo->ModelDesc = Define->ValStr3;
            }
        } else {
            SImsg(SIM_UNKN, "PCI device 0x%04x from %s (0x%04x)", 
                  DeviceID, DevInfo->Vendor, VendorID);
        }
    }

    if (!DevType && !DevInfo->Model && !DevInfo->ModelDesc && 
        !DevInfo->ClassType)
        DevInfo->ModelDesc = "PCI";

    if (Info->Bus >= 0 && Info->Unit >= 0 && Info->SubUnit >= 0) {
        (void) snprintf(Buff, sizeof(Buff), "pci%d:%d:%d", 
                        Info->Bus, Info->Unit, Info->SubUnit);
        AddDevDesc(DevInfo, Buff, "PCI Name", DA_APPEND);
    }
    if (VendorID) {
        (void) snprintf(Buff, sizeof(Buff), "0x%04x", VendorID);
        AddDevDesc(DevInfo, Buff, "PCI Vendor ID", DA_APPEND);
    }
    if (DeviceID) {
        (void) snprintf(Buff, sizeof(Buff), "0x%04x", DeviceID);
        AddDevDesc(DevInfo, Buff, "PCI Device ID", DA_APPEND);
    }
#define VI(i)   ( (PCIid_t)(i) != 0 && (PCIid_t)(i) != (PCIid_t)-1 )
    if (VI(Info->Class)) {
        (void) snprintf(Buff, sizeof(Buff), "0x%06x", Info->Class);
        AddDevDesc(DevInfo, Buff, "PCI Device Class", DA_APPEND);
    }
    if (VI(Info->SubDeviceID)) {
        (void) snprintf(Buff, sizeof(Buff), "0x%08lx", Info->SubDeviceID);
        AddDevDesc(DevInfo, Buff, "PCI Device Sub Vendor ID", DA_APPEND);
    }
    if (VI(Info->Revision)) {
        (void) snprintf(Buff, sizeof(Buff), "0x%02x", Info->Revision);
        AddDevDesc(DevInfo, Buff, "PCI Device Revision", DA_APPEND);
    }
    if (VI(Info->Header)) {
        (void) snprintf(Buff, sizeof(Buff), "0x%02x", Info->Header);
        AddDevDesc(DevInfo, Buff, "PCI Device Header", DA_APPEND);
    }
#undef VI
}

/*
 * Create and return a new PCInfo_t
 */
extern PCIinfo_t *PCInewInfo(Info)
     PCIinfo_t                 *Info;
{
    PCIinfo_t                  *New;

    if (Info) {
        (void) memset(Info, 0, sizeof(PCIinfo_t));
        New = Info;
    } else
        New = (PCIinfo_t *) xcalloc(1, sizeof(PCIinfo_t));

    New->Bus = New->Unit = New->SubUnit = -1;
    New->Header = New->Revision = New->Class = New->SubDeviceID = -1;

    return(New);
}