pci.cpp

MONA是为数不多的C++语言编写的一个很小的操作系统

/*!
    \file   Pci.cpp
    \brief  PCI儔僀僽儔儕 PCI僋儔僗

    Copyright (c) 2004 Yamami
    All rights reserved.
    License=MIT/X License

    \author  Yamami
    \version $Revision: 1.1 $
    \date   create:2004/10/15 update:$Date: 2004/10/18 09:09:06 $
*/

/*! \class Pci
 *  \brief PCI儔僀僽儔儕 PCI僋儔僗
 */


#include <monapi.h>
#include <monapi/messages.h>
#include <monapi/CString.h>
#include <pci/Pci.h>

//PCIINFO僼傽僀儖
#define PCIINFO_FILE "libPci.a"

using namespace MonAPI;




/*!
    \brief initialize
         Pci 僐儞僗僩儔僋僞
    \author Yamami
    \date   create:2004/10/15 update:$Date: 2004/10/18 09:09:06 $
*/
Pci::Pci()
{
    //I/O庢摼
    syscall_get_io();

}


/*!
    \brief initialize
         Pci 僨僗僋僩儔僋僞
    \author Yamami
    \date   create:2004/10/15 update:$Date: 2004/10/18 09:09:06 $
*/
Pci::~Pci() 
{
    //偙偙偱丄I/O傪夝彍偟偨偄偑丒丒丒

}




/*!
    \brief CheckPciExist
         Pci僨僶僀僗懚嵼妋擣丅巜掕偟偨Vendor/Device偺PCI僨僶僀僗偺懚嵼傪妋擣偡傞丅
    \author Yamami
    \param  word Vendor [in] 儀儞僟乕ID
    \param  word Device [in] 僨僶僀僗ID
    \return PciInf峔憿懱傊偺億僀儞僞
    \date   create:2004/10/15 update:$Date: 2004/10/18 09:09:06 $
*/
PciInf* Pci::CheckPciExist(word ChkVendor , word ChkDevice ) {
    
    byte DeviceNo;
    dword Vendor_Dev;

    word Vendor;
    word Device;

    dword BaseAd;
    dword  IrqLine;
    
    PciInf RetPciInf; //曉媝梡 PciInf峔憿懱

    //曉媝抣弶婜壔 僨僶僀僗偼懚嵼偟側偄丅
    RetPciInf.Exist = 1;

    //Yamami!!! 2004/10/18 PCI忣曬僼傽僀儖偼丄僶儞僪儖偱偼柍偔丄撈棫偝偣傞曽岦偱
    //CString bundlePath = MonAPI::System::getBundlePath();
    //pciinfo僼傽僀儖傪僆乕僾儞
    //monapi_cmemoryinfo* pciinfData = monapi_call_file_decompress_bz2_file(bundlePath + "/" + PCIINFO_FILE, MONAPI_TRUE);
    //僄儔乕張棟
    //if(pciinfData == NULL){
    //    printf("PCI DATA FILE OPEN ERROR !!!\n");
    //}

    //僶僗斣崋0偵偮偄偰丄僨僶僀僗斣崋傪0乣31偺偦傟偧傟偵偮偄偰丄儀儞僟乕ID傪撉傒弌偡
    for(DeviceNo = 0; DeviceNo < 32 ; DeviceNo++ ){
        //ReadConfig 傪梡偄偰Vendor偺庢摼
        Vendor = ReadConfig(0, DeviceNo, 0, PCI_VENDOR_ID, 2);
        
        if (Vendor != 0xFFFF){
            Device = ReadConfig(0, DeviceNo, 0, PCI_DEVICE_ID, 2);
            if (Device != 0xFFFF && ChkVendor == Vendor && ChkDevice == Device){
                //僨僶僀僗偑懚嵼偡傞丅
                //僨僶僀僗偲儀儞僟乕傪寢崌 getPciInfName 偵僀儞僞乕僼僃乕僗傪偁傢偣傞丅
                Vendor_Dev = Vendor + (dword)(Device << 16);
                
                //Base傾僪儗僗偺庢摼
                BaseAd = ReadConfig(0, DeviceNo, 0, PCI_BASE_ADDRESS1, 4);
                
                //IRQ儔僀儞偺庢摼  google PCI IRQ庢摼偱専嶕
                IrqLine = ReadConfig(0, DeviceNo, 0, PCI_IRQ_LINE, 1);
                
                //儀儞僟乕柤徧/僨僶僀僗柤徧偺庢摼
                CString VendorName;
                CString DeviceName;

                //CString Dummy = getPciInfName(pciinfData->Data , Vendor_Dev , &VendorName , &DeviceName);
                
                //曉媝抣惗惉
                RetPciInf.Exist = 0;
                RetPciInf.DeviceNo = DeviceNo;
                RetPciInf.Vendor = Vendor;
                RetPciInf.Device = Device;
                RetPciInf.VendorName = VendorName;
                RetPciInf.DeviceName = DeviceName;
                RetPciInf.BaseAd = BaseAd;
                RetPciInf.IrqLine = IrqLine;
                
                //尒偮偐偭偨応崌偼丄懄儖乕僾傪敳偗傞
                break;
            }
        }
    }

    //僼傽僀儖屻張棟
    //monapi_cmemoryinfo_dispose(pciinfData);
    //monapi_cmemoryinfo_delete(pciinfData);

    //Return
    return &RetPciInf;
    
}


/*!
    \brief ReadConfig
        PCI僨僶僀僗忣曬庢摼
    \param  byte bus [in] 僶僗斣崋
    \param  byte deviceid [in] 僨僶僀僗斣崋
    \param  byte func [in] 僼傽儞僋僔儑儞斣崋
    \param  byte reg [in] 儗僕僗僞傾僪儗僗
    \param  byte readSize [I] 庢摼僒僀僘
    \return dword 庢摼儗僕僗僞偺抣

    \author Yamami
    \date   create:2004/05/15 update:2004/05/15
*/
dword Pci::ReadConfig(byte bus, byte device, byte function, byte reg, byte readSize)
{
   dword result;
   PciPacket packet;

   packet.p.enabled   = 1;
   packet.p.bus       = bus;
   packet.p.device    = device;
   packet.p.function  = function;
   packet.p.reg       = reg & ~3;
   packet.p.reserved1 = 0;
   packet.p.reserved2 = 0;

   /* set request and enable */
   outp32(REG_CONFIG_ADDRESS, packet.command);

   switch (readSize)
   {
   case 1:
       result = inp8(REG_CONFIG_DATA + (reg & 3));
       break;

   case 2:
       result = inp16(REG_CONFIG_DATA + (reg & 3));
       break;

   case 4:
       result = inp32(REG_CONFIG_DATA + (reg & 3));
       break;

   default:
       result = 0xFFFFFFFF;
       break;
   }

   packet.p.enabled = 0;
   outp32(REG_CONFIG_ADDRESS, packet.command);
   return result;
}



/*!
    \brief IsLineSeparator
        僙僷儗乕僞敾掕

    \param  char ch [IN] 僉儍儔僋僞
    \return bool 僙僷儗乕僞暥帤側傜true 埲奜側傜false
    \author Tino巵
    \date   create:2004/06/111 update:2004/06/11
*/
inline bool Pci::IsLineSeparator(char ch)
{
    return ch == '\r' || ch == '\n' || ch == '\0';
}


/*!
    \brief getPciInfName
        PCI忣曬柤徧(儀儞僟乕丄僨僶僀僗)忣曬庢摼
        PCI儗僕僗僞抣 傪堷悢偵偲傝丄PCIINF.TXT 偐傜奩摉偡傞儀儞僟乕柤徧儀儞僟柤徧傪庢摼偡傞丅丅
    \param  byte* PciInfData [IN] PCI忣曬僨乕僞
    \param  dword InValue [IN] PCI儗僕僗僞抣(儀儞僟乕CD & 僨僶僀僗CD)
    \param  CString& VendorName [OUT] 儀儞僟乕柤徧
    \param  CString& DeviceName [OUT] 僨僶僀僗柤徧

    \return MonAPI::CString dummy(僟儈乕栠傝抣)

    \author Yamami
    \date   create:2004/05/16 update:2004/06/11
*/
CString Pci::getPciInfName( byte* PciInfData, dword InValue , CString* VendorName , CString* DeviceName){

    word Vendor;
    word Device;

    //儀儞僟乕ID偺庢摼
    Vendor = InValue & 0x0000FFFF;
    Device = InValue >> 16;

    char VendorHex[5];    //儀儞僟乕CD奿擺梡
    char DeviceHex[5];    //儀儞僟乕CD奿擺梡
    sprintf(VendorHex, "%04X", Vendor);
    sprintf(DeviceHex, "%04X", Device);

    //NULL傑偱孞傝曉偟
    while (*PciInfData != 0){

        //printf("%c",*PciInfData);

        //傑偢丄儀儞僟乕柤徧傪扵偡
        //儔僀儞僙僷儗乕僞側傜師偺暥帤傊
        if (IsLineSeparator(*PciInfData)){
            PciInfData++;
        }
        else if (strncmp((const char*)PciInfData, VendorHex, 4) == 0){
            const char* ps = (const char*)(PciInfData + 5), * pe = ps;
            for (; !IsLineSeparator(*pe); pe++);

            //return CString(ps, pe - ps);
            //儀儞僟乕忣曬妋掕
            *VendorName = CString(ps, pe - ps);

            //printf("%s\n",(const char*)VendorName);

            //儀儞僟乕柤埲壓偺僨僶僀僗傪専嶕偡傞丅
            //1峴撉傒旘偽偟
            for (; !IsLineSeparator(*PciInfData); PciInfData++);
            while (*PciInfData != 0){
                if (IsLineSeparator(*PciInfData)){
                    PciInfData++;

                    //儔僀儞僙僷儗乕僞偺師偑僞僽側傜丄僨僶僀僗忣曬
                    if (strncmp((const char*)PciInfData, "\t", 1) == 0){
                        PciInfData++;
                        if (strncmp((const char*)PciInfData, DeviceHex, 4) == 0){
                            const char* ps = (const char*)(PciInfData + 5), * pe = ps;
                            for (; !IsLineSeparator(*pe); pe++);
                            *DeviceName = CString(ps, pe - ps);

                            //printf("%s\n",(const char*)DeviceName);

                            return "dumy";
                        }
                        else{
                            //師偺僨僶僀僗傊
                            for (; !IsLineSeparator(*PciInfData); PciInfData++);
                        }
                    }
                    //儀儞僟乕偑曄峏偝傟傞傑偱撉傫偱尒偮偐傜側偐偭偨傜丄晄柧偲偡傞丅
                    else{
                        *DeviceName = "???";
                        //printf("%s\n",(const char*)DeviceName);
                        return "dumy";
                    }
                }
                else{
                    printf("tobashi\n");

                    //偳傟偵傕奩摉偟側偄峴偼撉傒旘偽偟
                    for (; !IsLineSeparator(*PciInfData); PciInfData++);
                }

            }
        }
        else{
            //偳傟偵傕奩摉偟側偄峴偼撉傒旘偽偟
            for (; !IsLineSeparator(*PciInfData); PciInfData++);
        }
    }

    // 晄柧
    *VendorName = "???";
    *DeviceName = "???";
    return "???";
}