X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=dev%2Fpcidev.hh;h=c0fe47ac4461d54ba3255b368c14d0490c076d60;hb=425dda00df994b2483850e80260618b2a1a957bf;hp=85f3442982023eb34368aae1dbe42876d658a145;hpb=f2b8df24208e3dc0522ed64f2b57e89268db61ae;p=gem5.git

diff --git a/dev/pcidev.hh b/dev/pcidev.hh
index 85f344298..c0fe47ac4 100644
--- a/dev/pcidev.hh
+++ b/dev/pcidev.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003 The Regents of The University of Michigan
+ * Copyright (c) 2004 The Regents of The University of Michigan
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,42 +27,144 @@
  */
 
 /* @file
- * PCI configspace devices
+ * Interface for devices using PCI configuration
  */
 
 #ifndef __PCI_DEV_HH__
 #define __PCI_DEV_HH__
 
-#include "mem/functional_mem/mmap_device.hh"
 #include "dev/pcireg.h"
-class PCIConfigAll;
+#include "dev/io_device.hh"
 
-/*
- * PCI device configuration device.
+class PciConfigAll;
+class MemoryController;
+
+
+/**
+ * This class encapulates the first 64 bytes of a singles PCI
+ * devices config space that in configured by the configuration file.
+ */
+class PciConfigData : public SimObject
+{
+  public:
+    /**
+     * Constructor to initialize the devices config space to 0.
+     */
+    PciConfigData(const std::string &name)
+        : SimObject(name)
+    {
+        memset(config.data, 0, sizeof(config.data));
+        memset(BARAddrs, 0, sizeof(BARAddrs));
+        memset(BARSize, 0, sizeof(BARSize));
+    }
+
+    /** The first 64 bytes */
+    PCIConfig config;
+
+    /** The size of the BARs */
+    uint32_t BARSize[6];
+
+    /** The addresses of the BARs */
+    Addr BARAddrs[6];
+};
+
+/**
+ * PCI device, base implemnation is only config space.
  * Each device is connected to a PCIConfigSpace device
  * which returns -1 for everything but the pcidevs that
  * register with it. This object registers with the PCIConfig space
  * object.
  */
-class PciDev : public MMapDevice
+class PciDev : public DmaDevice
 {
-  private:
-    uint32_t Bus;
-    uint32_t Device;
-    uint32_t Function;
-  public:
-    PciDev(const std::string &name, PCIConfigAll *cf, uint32_t bus,
-           uint32_t dev, uint32_t func);
+  protected:
+    MemoryController *mmu;
+    /** A pointer to the configspace all object that calls
+     * us when a read comes to this particular device/function.
+     */
+    PciConfigAll *configSpace;
 
-    PCIConfigAll *ConfigSpace;
+    /**
+     * A pointer to the object that contains the first 64 bytes of
+     * config space
+     */
+    PciConfigData *configData;
+
+    /** The bus number we are on */
+    uint32_t busNum;
+
+    /** The device number we have */
+    uint32_t deviceNum;
+
+    /** The function number */
+    uint32_t functionNum;
+
+    /** The current config space. Unlike the PciConfigData this is updated
+     * during simulation while continues to refelect what was in the config file.
+     */
     PCIConfig config;
+
+    /** The size of the BARs */
     uint32_t BARSize[6];
 
+    /** The current address mapping of the BARs */
+    Addr BARAddrs[6];
+
+  public:
+    /**
+     * Constructor for PCI Dev. This function copies data from the config file
+     * object PCIConfigData and registers the device with a PciConfigAll object.
+     * @param name name of the object
+     * @param mmu a pointer to the memory controller
+     * @param cf a pointer to the config space object that this device need to
+     *           register with
+     * @param cd A pointer to the config space values specified in the conig file
+     * @param bus the bus this device is on
+     * @param dev the device id of this device
+     * @param func the function number of this device
+     */
+    PciDev(const std::string &name, MemoryController *mmu, PciConfigAll *cf,
+           PciConfigData *cd, uint32_t bus, uint32_t dev, uint32_t func);
+
+    virtual Fault read(MemReqPtr &req, uint8_t *data) {
+        return No_Fault;
+    }
+    virtual Fault write(MemReqPtr &req, const uint8_t *data) {
+        return No_Fault;
+    }
+
+    /**
+     * Write to the PCI config space data that is stored locally. This may be
+     * overridden by the device but at some point it will eventually call this
+     * for normal operations that it does not need to override.
+     * @param offset the offset into config space
+     * @param size the size of the write
+     * @param data the data to write
+     */
     virtual void WriteConfig(int offset, int size, uint32_t data);
-    virtual void ReadConfig(int offset, int size, uint8_t *data);
 
 
+    /**
+     * Read from the PCI config space data that is stored locally. This may be
+     * overridden by the device but at some point it will eventually call this
+     * for normal operations that it does not need to override.
+     * @param offset the offset into config space
+     * @param size the size of the read
+     * @param data pointer to the location where the read value should be stored
+     */
+    virtual void ReadConfig(int offset, int size, uint8_t *data);
+
+    /**
+     * Serialize this object to the given output stream.
+     * @param os The stream to serialize to.
+     */
     virtual void serialize(std::ostream &os);
+
+    /**
+     * Reconstruct the state of this object from a checkpoint.
+     * @param cp The checkpoint use.
+     * @param section The section name of this object
+     */
     virtual void unserialize(Checkpoint *cp, const std::string &section);
 };