From d9e8ecbf46ead49c2c8174c1362a5cb136b4b5f9 Mon Sep 17 00:00:00 2001 From: Ali Saidi Date: Thu, 22 Jan 2004 00:36:26 -0500 Subject: renamed tsunami_dma to tsunami_io dev/tsunami_io.cc: renamed to io instead of dma since it's more than the DMA controller now dev/tsunami_io.hh: renamed from dma to io since it's more than dma just now --HG-- rename : dev/tsunami_dma.cc => dev/tsunami_io.cc rename : dev/tsunami_dma.hh => dev/tsunami_io.hh extra : convert_revision : 4ffb69679eb7cea5725fae3446e088899f1f9315 --- dev/tsunami_dma.cc | 127 ----------------------------------------------------- dev/tsunami_dma.hh | 64 --------------------------- dev/tsunami_io.cc | 127 +++++++++++++++++++++++++++++++++++++++++++++++++++++ dev/tsunami_io.hh | 64 +++++++++++++++++++++++++++ 4 files changed, 191 insertions(+), 191 deletions(-) delete mode 100644 dev/tsunami_dma.cc delete mode 100644 dev/tsunami_dma.hh create mode 100644 dev/tsunami_io.cc create mode 100644 dev/tsunami_io.hh diff --git a/dev/tsunami_dma.cc b/dev/tsunami_dma.cc deleted file mode 100644 index 4b1dca74c..000000000 --- a/dev/tsunami_dma.cc +++ /dev/null @@ -1,127 +0,0 @@ -/* $Id$ */ - -/* @file - * Tsunami DMA fake - */ - -#include -#include -#include - -#include "base/trace.hh" -#include "cpu/exec_context.hh" -#include "dev/console.hh" -#include "dev/etherdev.hh" -#include "dev/scsi_ctrl.hh" -#include "dev/tlaser_clock.hh" -#include "dev/tsunami_dma.hh" -#include "dev/tsunamireg.h" -#include "dev/tsunami.hh" -#include "mem/functional_mem/memory_control.hh" -#include "sim/builder.hh" -#include "sim/system.hh" - -using namespace std; - -TsunamiDMA::TsunamiDMA(const string &name, /*Tsunami *t,*/ - Addr addr, Addr mask, MemoryController *mmu) - : MmapDevice(name, addr, mask, mmu)/*, tsunami(t) */ -{ - -} - -Fault -TsunamiDMA::read(MemReqPtr req, uint8_t *data) -{ - DPRINTF(Tsunami, "dma read va=%#x size=%d IOPorrt=%#x\n", - req->vaddr, req->size, req->vaddr & 0xfff); - - // Addr daddr = (req->paddr & addr_mask) >> 6; -// ExecContext *xc = req->xc; -// int cpuid = xc->cpu_id; - panic("I/O Read - va%#x size %d\n", req->vaddr, req->size); - // *(uint64_t*)data = 0x00; - - return No_Fault; -} - -Fault -TsunamiDMA::write(MemReqPtr req, const uint8_t *data) -{ - DPRINTF(Tsunami, "dma write - va=%#x size=%d IOPort=%#x\n", - req->vaddr, req->size, req->vaddr & 0xfff); - - Addr daddr = (req->paddr & addr_mask); - - switch(req->size) { - case sizeof(uint8_t): - switch(daddr) { - case TSDEV_PIC1_MASK: - mask1 = *(uint8_t*)data; - return No_Fault; - case TSDEV_PIC2_MASK: - mask2 = *(uint8_t*)data; - return No_Fault; - case TSDEV_DMA1_RESET: - return No_Fault; - case TSDEV_DMA2_RESET: - return No_Fault; - case TSDEV_DMA1_MODE: - mode1 = *(uint8_t*)data; - return No_Fault; - case TSDEV_DMA2_MODE: - mode2 = *(uint8_t*)data; - return No_Fault; - case TSDEV_DMA1_MASK: - case TSDEV_DMA2_MASK: - return No_Fault; - default: - panic("I/O Write - va%#x size %d\n", req->vaddr, req->size); - } - case sizeof(uint16_t): - case sizeof(uint32_t): - case sizeof(uint64_t): - default: - panic("I/O Write - invalid size - va %#x size %d\n", req->vaddr, req->size); - } - - - return No_Fault; -} - -void -TsunamiDMA::serialize(std::ostream &os) -{ - // code should be written -} - -void -TsunamiDMA::unserialize(Checkpoint *cp, const std::string §ion) -{ - //code should be written -} - -BEGIN_DECLARE_SIM_OBJECT_PARAMS(TsunamiDMA) - - // SimObjectParam tsunami; - SimObjectParam mmu; - Param addr; - Param mask; - -END_DECLARE_SIM_OBJECT_PARAMS(TsunamiDMA) - -BEGIN_INIT_SIM_OBJECT_PARAMS(TsunamiDMA) - -// INIT_PARAM(tsunami, "Tsunami"), - INIT_PARAM(mmu, "Memory Controller"), - INIT_PARAM(addr, "Device Address"), - INIT_PARAM(mask, "Address Mask") - -END_INIT_SIM_OBJECT_PARAMS(TsunamiDMA) - -CREATE_SIM_OBJECT(TsunamiDMA) -{ - return new TsunamiDMA(getInstanceName(), /*tsunami,*/ addr, mask, mmu); -} - -REGISTER_SIM_OBJECT("TsunamiDMA", TsunamiDMA) diff --git a/dev/tsunami_dma.hh b/dev/tsunami_dma.hh deleted file mode 100644 index f23abce2d..000000000 --- a/dev/tsunami_dma.hh +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright (c) 2003 The Regents of The University of Michigan - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer; - * redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution; - * neither the name of the copyright holders nor the names of its - * contributors may be used to endorse or promote products derived from - * this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/* @file - * Tsunnami Fake DMA memory map - */ - -#ifndef __TSUNAMI_DMA_HH__ -#define __TSUNAMI_DMA_HH__ - -#include "mem/functional_mem/mmap_device.hh" -#include "dev/tsunami.hh" - -/* - * Tsunami CChip - */ -class TsunamiDMA : public MmapDevice -{ - public: - - protected: - - uint8_t mask1; - uint8_t mask2; - uint8_t mode1; - uint8_t mode2; - - public: - TsunamiDMA(const std::string &name, /*Tsunami *t,*/ - Addr addr, Addr mask, MemoryController *mmu); - - virtual Fault read(MemReqPtr req, uint8_t *data); - virtual Fault write(MemReqPtr req, const uint8_t *data); - - virtual void serialize(std::ostream &os); - virtual void unserialize(Checkpoint *cp, const std::string §ion); -}; - -#endif // __TSUNAMI_DMA_HH__ diff --git a/dev/tsunami_io.cc b/dev/tsunami_io.cc new file mode 100644 index 000000000..d5f2af960 --- /dev/null +++ b/dev/tsunami_io.cc @@ -0,0 +1,127 @@ +/* $Id$ */ + +/* @file + * Tsunami DMA fake + */ + +#include +#include +#include + +#include "base/trace.hh" +#include "cpu/exec_context.hh" +#include "dev/console.hh" +#include "dev/etherdev.hh" +#include "dev/scsi_ctrl.hh" +#include "dev/tlaser_clock.hh" +#include "dev/tsunami_io.hh" +#include "dev/tsunamireg.h" +#include "dev/tsunami.hh" +#include "mem/functional_mem/memory_control.hh" +#include "sim/builder.hh" +#include "sim/system.hh" + +using namespace std; + +TsunamiIO::TsunamiIO(const string &name, /*Tsunami *t,*/ + Addr addr, Addr mask, MemoryController *mmu) + : MmapDevice(name, addr, mask, mmu)/*, tsunami(t) */ +{ + +} + +Fault +TsunamiIO::read(MemReqPtr req, uint8_t *data) +{ + DPRINTF(Tsunami, "io read va=%#x size=%d IOPorrt=%#x\n", + req->vaddr, req->size, req->vaddr & 0xfff); + + // Addr daddr = (req->paddr & addr_mask) >> 6; +// ExecContext *xc = req->xc; +// int cpuid = xc->cpu_id; + panic("I/O Read - va%#x size %d\n", req->vaddr, req->size); + // *(uint64_t*)data = 0x00; + + return No_Fault; +} + +Fault +TsunamiIO::write(MemReqPtr req, const uint8_t *data) +{ + DPRINTF(Tsunami, "io write - va=%#x size=%d IOPort=%#x\n", + req->vaddr, req->size, req->vaddr & 0xfff); + + Addr daddr = (req->paddr & addr_mask); + + switch(req->size) { + case sizeof(uint8_t): + switch(daddr) { + case TSDEV_PIC1_MASK: + mask1 = *(uint8_t*)data; + return No_Fault; + case TSDEV_PIC2_MASK: + mask2 = *(uint8_t*)data; + return No_Fault; + case TSDEV_DMA1_RESET: + return No_Fault; + case TSDEV_DMA2_RESET: + return No_Fault; + case TSDEV_DMA1_MODE: + mode1 = *(uint8_t*)data; + return No_Fault; + case TSDEV_DMA2_MODE: + mode2 = *(uint8_t*)data; + return No_Fault; + case TSDEV_DMA1_MASK: + case TSDEV_DMA2_MASK: + return No_Fault; + default: + panic("I/O Write - va%#x size %d\n", req->vaddr, req->size); + } + case sizeof(uint16_t): + case sizeof(uint32_t): + case sizeof(uint64_t): + default: + panic("I/O Write - invalid size - va %#x size %d\n", req->vaddr, req->size); + } + + + return No_Fault; +} + +void +TsunamiIO::serialize(std::ostream &os) +{ + // code should be written +} + +void +TsunamiIO::unserialize(Checkpoint *cp, const std::string §ion) +{ + //code should be written +} + +BEGIN_DECLARE_SIM_OBJECT_PARAMS(TsunamiIO) + + // SimObjectParam tsunami; + SimObjectParam mmu; + Param addr; + Param mask; + +END_DECLARE_SIM_OBJECT_PARAMS(TsunamiIO) + +BEGIN_INIT_SIM_OBJECT_PARAMS(TsunamiIO) + +// INIT_PARAM(tsunami, "Tsunami"), + INIT_PARAM(mmu, "Memory Controller"), + INIT_PARAM(addr, "Device Address"), + INIT_PARAM(mask, "Address Mask") + +END_INIT_SIM_OBJECT_PARAMS(TsunamiIO) + +CREATE_SIM_OBJECT(TsunamiIO) +{ + return new TsunamiIO(getInstanceName(), /*tsunami,*/ addr, mask, mmu); +} + +REGISTER_SIM_OBJECT("TsunamiIO", TsunamiIO) diff --git a/dev/tsunami_io.hh b/dev/tsunami_io.hh new file mode 100644 index 000000000..943df77c2 --- /dev/null +++ b/dev/tsunami_io.hh @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2003 The Regents of The University of Michigan + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* @file + * Tsunnami Fake DMA memory map + */ + +#ifndef __TSUNAMI_DMA_HH__ +#define __TSUNAMI_DMA_HH__ + +#include "mem/functional_mem/mmap_device.hh" +#include "dev/tsunami.hh" + +/* + * Tsunami I/O device + */ +class TsunamiIO : public MmapDevice +{ + public: + + protected: + + uint8_t mask1; + uint8_t mask2; + uint8_t mode1; + uint8_t mode2; + + public: + TsunamiIO(const std::string &name, /*Tsunami *t,*/ + Addr addr, Addr mask, MemoryController *mmu); + + virtual Fault read(MemReqPtr req, uint8_t *data); + virtual Fault write(MemReqPtr req, const uint8_t *data); + + virtual void serialize(std::ostream &os); + virtual void unserialize(Checkpoint *cp, const std::string §ion); +}; + +#endif // __TSUNAMI_IO_HH__ -- cgit v1.2.3