Update copyright dates and author list SConscript: arch/alpha/alpha_linux_process.cc: arch/alpha/alpha_linux_process.hh: arch/alpha/alpha_memory.cc: arch/alpha/alpha_memory.hh: arch/alpha/alpha_tru64_process.cc: arch/alpha/alpha_tru64_process.hh: arch/alpha/aout_machdep.h: arch/alpha/arguments.cc: arch/alpha/arguments.hh: arch/alpha/ev5.cc: arch/alpha/ev5.hh: arch/alpha/faults.cc: arch/alpha/faults.hh: arch/alpha/isa_desc: arch/alpha/isa_traits.hh: arch/alpha/osfpal.cc: arch/alpha/osfpal.hh: arch/alpha/pseudo_inst.cc: arch/alpha/pseudo_inst.hh: arch/alpha/vptr.hh: arch/alpha/vtophys.cc: arch/alpha/vtophys.hh: base/bitfield.hh: base/callback.hh: base/circlebuf.cc: base/circlebuf.hh: base/cprintf.cc: base/cprintf.hh: base/cprintf_formats.hh: base/crc.hh: base/date.cc: base/dbl_list.hh: base/endian.hh: base/fast_alloc.cc: base/fast_alloc.hh: base/fifo_buffer.cc: base/fifo_buffer.hh: base/hashmap.hh: base/hostinfo.cc: base/hostinfo.hh: base/hybrid_pred.cc: base/hybrid_pred.hh: base/inet.cc: base/inet.hh: base/inifile.cc: base/inifile.hh: base/intmath.cc: base/intmath.hh: base/match.cc: base/match.hh: base/misc.cc: base/misc.hh: base/mod_num.hh: base/mysql.cc: base/mysql.hh: base/output.cc: base/output.hh: base/pollevent.cc: base/pollevent.hh: base/predictor.hh: base/random.cc: base/random.hh: base/range.cc: base/range.hh: base/refcnt.hh: base/remote_gdb.cc: base/remote_gdb.hh: base/res_list.hh: base/sat_counter.cc: base/sat_counter.hh: base/sched_list.hh: base/socket.cc: base/socket.hh: base/statistics.cc: base/statistics.hh: base/compression/lzss_compression.cc: base/compression/lzss_compression.hh: base/compression/null_compression.hh: base/loader/aout_object.cc: base/loader/aout_object.hh: base/loader/ecoff_object.cc: base/loader/ecoff_object.hh: base/loader/elf_object.cc: base/loader/elf_object.hh: base/loader/object_file.cc: base/loader/object_file.hh: base/loader/symtab.cc: base/loader/symtab.hh: base/stats/events.cc: base/stats/events.hh: base/stats/flags.hh: base/stats/mysql.cc: base/stats/mysql.hh: base/stats/mysql_run.hh: base/stats/output.hh: base/stats/statdb.cc: base/stats/statdb.hh: base/stats/text.cc: base/stats/text.hh: base/stats/types.hh: base/stats/visit.cc: base/stats/visit.hh: base/str.cc: base/str.hh: base/time.cc: base/time.hh: base/timebuf.hh: base/trace.cc: base/trace.hh: base/userinfo.cc: base/userinfo.hh: build/SConstruct: cpu/base.cc: cpu/base.hh: cpu/base_dyn_inst.cc: cpu/base_dyn_inst.hh: cpu/exec_context.cc: cpu/exec_context.hh: cpu/exetrace.cc: cpu/exetrace.hh: cpu/inst_seq.hh: cpu/intr_control.cc: cpu/intr_control.hh: cpu/memtest/memtest.cc: cpu/pc_event.cc: cpu/pc_event.hh: cpu/smt.hh: cpu/static_inst.cc: cpu/static_inst.hh: cpu/memtest/memtest.hh: cpu/o3/sat_counter.cc: cpu/o3/sat_counter.hh: cpu/ozone/cpu.hh: cpu/simple/cpu.cc: cpu/simple/cpu.hh: cpu/trace/opt_cpu.cc: cpu/trace/opt_cpu.hh: cpu/trace/reader/ibm_reader.cc: cpu/trace/reader/ibm_reader.hh: cpu/trace/reader/itx_reader.cc: cpu/trace/reader/itx_reader.hh: cpu/trace/reader/m5_reader.cc: cpu/trace/reader/m5_reader.hh: cpu/trace/reader/mem_trace_reader.cc: cpu/trace/reader/mem_trace_reader.hh: cpu/trace/trace_cpu.cc: cpu/trace/trace_cpu.hh: dev/alpha_access.h: dev/alpha_console.cc: dev/alpha_console.hh: dev/baddev.cc: dev/baddev.hh: dev/disk_image.cc: dev/disk_image.hh: dev/etherbus.cc: dev/etherbus.hh: dev/etherdump.cc: dev/etherdump.hh: dev/etherint.cc: dev/etherint.hh: dev/etherlink.cc: dev/etherlink.hh: dev/etherpkt.cc: dev/etherpkt.hh: dev/ethertap.cc: dev/ethertap.hh: dev/ide_ctrl.cc: dev/ide_ctrl.hh: dev/ide_disk.cc: dev/ide_disk.hh: dev/io_device.cc: dev/io_device.hh: dev/ns_gige.cc: dev/ns_gige.hh: dev/ns_gige_reg.h: dev/pciconfigall.cc: dev/pciconfigall.hh: dev/pcidev.cc: dev/pcidev.hh: dev/pcireg.h: dev/pktfifo.cc: dev/pktfifo.hh: dev/platform.cc: dev/platform.hh: dev/simconsole.cc: dev/simconsole.hh: dev/simple_disk.cc: dev/simple_disk.hh: dev/sinic.cc: dev/sinic.hh: dev/sinicreg.hh: dev/tsunami.cc: dev/tsunami.hh: dev/tsunami_cchip.cc: dev/tsunami_cchip.hh: dev/tsunami_io.cc: dev/tsunami_io.hh: dev/tsunami_pchip.cc: dev/tsunami_pchip.hh: dev/tsunamireg.h: dev/uart.cc: dev/uart.hh: dev/uart8250.cc: dev/uart8250.hh: docs/stl.hh: encumbered/cpu/full/op_class.hh: kern/kernel_stats.cc: kern/kernel_stats.hh: kern/linux/linux.hh: kern/linux/linux_syscalls.cc: kern/linux/linux_syscalls.hh: kern/linux/linux_system.cc: kern/linux/linux_system.hh: kern/linux/linux_threadinfo.hh: kern/linux/printk.cc: kern/linux/printk.hh: kern/system_events.cc: kern/system_events.hh: kern/tru64/dump_mbuf.cc: kern/tru64/dump_mbuf.hh: kern/tru64/mbuf.hh: kern/tru64/printf.cc: kern/tru64/printf.hh: kern/tru64/tru64.hh: kern/tru64/tru64_events.cc: kern/tru64/tru64_events.hh: kern/tru64/tru64_syscalls.cc: kern/tru64/tru64_syscalls.hh: kern/tru64/tru64_system.cc: kern/tru64/tru64_system.hh: python/SConscript: python/m5/__init__.py: python/m5/config.py: python/m5/convert.py: python/m5/multidict.py: python/m5/smartdict.py: sim/async.hh: sim/builder.cc: sim/builder.hh: sim/debug.cc: sim/debug.hh: sim/eventq.cc: sim/eventq.hh: sim/host.hh: sim/main.cc: sim/param.cc: sim/param.hh: sim/process.cc: sim/process.hh: sim/root.cc: sim/serialize.cc: sim/serialize.hh: sim/sim_events.cc: sim/sim_events.hh: sim/sim_exit.hh: sim/sim_object.cc: sim/sim_object.hh: sim/startup.cc: sim/startup.hh: sim/stat_control.cc: sim/stat_control.hh: sim/stats.hh: sim/syscall_emul.cc: sim/syscall_emul.hh: sim/system.cc: sim/system.hh: test/bitvectest.cc: test/circletest.cc: test/cprintftest.cc: test/genini.py: test/initest.cc: test/lru_test.cc: test/nmtest.cc: test/offtest.cc: test/paramtest.cc: test/rangetest.cc: test/sized_test.cc: test/stattest.cc: test/strnumtest.cc: test/symtest.cc: test/tokentest.cc: test/tracetest.cc: util/ccdrv/devtime.c: util/m5/m5.c: util/oprofile-top.py: util/rundiff: util/m5/m5op.h: util/m5/m5op.s: util/stats/db.py: util/stats/dbinit.py: util/stats/display.py: util/stats/info.py: util/stats/print.py: util/stats/stats.py: util/tap/tap.cc: Update copyright dates and author list --HG-- extra : convert_revision : 0faba08fc0fc0146f1efb7f61e4b043c020ff9e4
723 lines
22 KiB
C++
723 lines
22 KiB
C++
/*
|
|
* Copyright (c) 2004-2005 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.
|
|
*/
|
|
|
|
#include <cstddef>
|
|
#include <cstdlib>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "base/trace.hh"
|
|
#include "cpu/intr_control.hh"
|
|
#include "dev/ide_ctrl.hh"
|
|
#include "dev/ide_disk.hh"
|
|
#include "dev/pciconfigall.hh"
|
|
#include "dev/pcireg.h"
|
|
#include "dev/platform.hh"
|
|
#include "mem/bus/bus.hh"
|
|
#include "mem/bus/dma_interface.hh"
|
|
#include "mem/bus/pio_interface.hh"
|
|
#include "mem/bus/pio_interface_impl.hh"
|
|
#include "mem/functional/memory_control.hh"
|
|
#include "mem/functional/physical.hh"
|
|
#include "sim/builder.hh"
|
|
#include "sim/sim_object.hh"
|
|
|
|
using namespace std;
|
|
|
|
////
|
|
// Initialization and destruction
|
|
////
|
|
|
|
IdeController::IdeController(Params *p)
|
|
: PciDev(p)
|
|
{
|
|
// initialize the PIO interface addresses
|
|
pri_cmd_addr = 0;
|
|
pri_cmd_size = BARSize[0];
|
|
|
|
pri_ctrl_addr = 0;
|
|
pri_ctrl_size = BARSize[1];
|
|
|
|
sec_cmd_addr = 0;
|
|
sec_cmd_size = BARSize[2];
|
|
|
|
sec_ctrl_addr = 0;
|
|
sec_ctrl_size = BARSize[3];
|
|
|
|
// initialize the bus master interface (BMI) address to be configured
|
|
// via PCI
|
|
bmi_addr = 0;
|
|
bmi_size = BARSize[4];
|
|
|
|
// zero out all of the registers
|
|
memset(bmi_regs, 0, sizeof(bmi_regs));
|
|
memset(pci_regs, 0, sizeof(pci_regs));
|
|
|
|
// setup initial values
|
|
*(uint32_t *)&pci_regs[IDETIM] = 0x80008000; // enable both channels
|
|
*(uint8_t *)&bmi_regs[BMIS0] = 0x60;
|
|
*(uint8_t *)&bmi_regs[BMIS1] = 0x60;
|
|
|
|
// reset all internal variables
|
|
io_enabled = false;
|
|
bm_enabled = false;
|
|
memset(cmd_in_progress, 0, sizeof(cmd_in_progress));
|
|
|
|
// create the PIO and DMA interfaces
|
|
if (params()->host_bus) {
|
|
pioInterface = newPioInterface(name(), params()->hier,
|
|
params()->host_bus, this,
|
|
&IdeController::cacheAccess);
|
|
|
|
dmaInterface = new DMAInterface<Bus>(name() + ".dma",
|
|
params()->host_bus,
|
|
params()->host_bus, 1,
|
|
true);
|
|
pioLatency = params()->pio_latency * params()->host_bus->clockRate;
|
|
}
|
|
|
|
// setup the disks attached to controller
|
|
memset(disks, 0, sizeof(IdeDisk *) * 4);
|
|
|
|
if (params()->disks.size() > 3)
|
|
panic("IDE controllers support a maximum of 4 devices attached!\n");
|
|
|
|
for (int i = 0; i < params()->disks.size(); i++) {
|
|
disks[i] = params()->disks[i];
|
|
disks[i]->setController(this, dmaInterface);
|
|
}
|
|
}
|
|
|
|
IdeController::~IdeController()
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
if (disks[i])
|
|
delete disks[i];
|
|
}
|
|
|
|
////
|
|
// Utility functions
|
|
///
|
|
|
|
void
|
|
IdeController::parseAddr(const Addr &addr, Addr &offset, bool &primary,
|
|
RegType_t &type)
|
|
{
|
|
offset = addr;
|
|
|
|
if (addr >= pri_cmd_addr && addr < (pri_cmd_addr + pri_cmd_size)) {
|
|
offset -= pri_cmd_addr;
|
|
type = COMMAND_BLOCK;
|
|
primary = true;
|
|
} else if (addr >= pri_ctrl_addr &&
|
|
addr < (pri_ctrl_addr + pri_ctrl_size)) {
|
|
offset -= pri_ctrl_addr;
|
|
type = CONTROL_BLOCK;
|
|
primary = true;
|
|
} else if (addr >= sec_cmd_addr &&
|
|
addr < (sec_cmd_addr + sec_cmd_size)) {
|
|
offset -= sec_cmd_addr;
|
|
type = COMMAND_BLOCK;
|
|
primary = false;
|
|
} else if (addr >= sec_ctrl_addr &&
|
|
addr < (sec_ctrl_addr + sec_ctrl_size)) {
|
|
offset -= sec_ctrl_addr;
|
|
type = CONTROL_BLOCK;
|
|
primary = false;
|
|
} else if (addr >= bmi_addr && addr < (bmi_addr + bmi_size)) {
|
|
offset -= bmi_addr;
|
|
type = BMI_BLOCK;
|
|
primary = (offset < BMIC1) ? true : false;
|
|
} else {
|
|
panic("IDE controller access to invalid address: %#x\n", addr);
|
|
}
|
|
}
|
|
|
|
int
|
|
IdeController::getDisk(bool primary)
|
|
{
|
|
int disk = 0;
|
|
uint8_t *devBit = &dev[0];
|
|
|
|
if (!primary) {
|
|
disk += 2;
|
|
devBit = &dev[1];
|
|
}
|
|
|
|
disk += *devBit;
|
|
|
|
assert(*devBit == 0 || *devBit == 1);
|
|
|
|
return disk;
|
|
}
|
|
|
|
int
|
|
IdeController::getDisk(IdeDisk *diskPtr)
|
|
{
|
|
for (int i = 0; i < 4; i++) {
|
|
if ((long)diskPtr == (long)disks[i])
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
bool
|
|
IdeController::isDiskSelected(IdeDisk *diskPtr)
|
|
{
|
|
for (int i = 0; i < 4; i++) {
|
|
if ((long)diskPtr == (long)disks[i]) {
|
|
// is disk is on primary or secondary channel
|
|
int channel = i/2;
|
|
// is disk the master or slave
|
|
int devID = i%2;
|
|
|
|
return (dev[channel] == devID);
|
|
}
|
|
}
|
|
panic("Unable to find disk by pointer!!\n");
|
|
}
|
|
|
|
////
|
|
// Command completion
|
|
////
|
|
|
|
void
|
|
IdeController::setDmaComplete(IdeDisk *disk)
|
|
{
|
|
int diskNum = getDisk(disk);
|
|
|
|
if (diskNum < 0)
|
|
panic("Unable to find disk based on pointer %#x\n", disk);
|
|
|
|
if (diskNum < 2) {
|
|
// clear the start/stop bit in the command register
|
|
bmi_regs[BMIC0] &= ~SSBM;
|
|
// clear the bus master active bit in the status register
|
|
bmi_regs[BMIS0] &= ~BMIDEA;
|
|
// set the interrupt bit
|
|
bmi_regs[BMIS0] |= IDEINTS;
|
|
} else {
|
|
// clear the start/stop bit in the command register
|
|
bmi_regs[BMIC1] &= ~SSBM;
|
|
// clear the bus master active bit in the status register
|
|
bmi_regs[BMIS1] &= ~BMIDEA;
|
|
// set the interrupt bit
|
|
bmi_regs[BMIS1] |= IDEINTS;
|
|
}
|
|
}
|
|
|
|
////
|
|
// Bus timing and bus access functions
|
|
////
|
|
|
|
Tick
|
|
IdeController::cacheAccess(MemReqPtr &req)
|
|
{
|
|
// @todo Add more accurate timing to cache access
|
|
return curTick + pioLatency;
|
|
}
|
|
|
|
////
|
|
// Read and write handling
|
|
////
|
|
|
|
void
|
|
IdeController::ReadConfig(int offset, int size, uint8_t *data)
|
|
{
|
|
|
|
#if TRACING_ON
|
|
Addr origOffset = offset;
|
|
#endif
|
|
|
|
if (offset < PCI_DEVICE_SPECIFIC) {
|
|
PciDev::ReadConfig(offset, size, data);
|
|
} else {
|
|
if (offset >= PCI_IDE_TIMING && offset < (PCI_IDE_TIMING + 4)) {
|
|
offset -= PCI_IDE_TIMING;
|
|
offset += IDETIM;
|
|
|
|
if ((offset + size) > (IDETIM + 4))
|
|
panic("PCI read of IDETIM with invalid size\n");
|
|
} else if (offset == PCI_SLAVE_TIMING) {
|
|
offset -= PCI_SLAVE_TIMING;
|
|
offset += SIDETIM;
|
|
|
|
if ((offset + size) > (SIDETIM + 1))
|
|
panic("PCI read of SIDETIM with invalid size\n");
|
|
} else if (offset == PCI_UDMA33_CTRL) {
|
|
offset -= PCI_UDMA33_CTRL;
|
|
offset += UDMACTL;
|
|
|
|
if ((offset + size) > (UDMACTL + 1))
|
|
panic("PCI read of UDMACTL with invalid size\n");
|
|
} else if (offset >= PCI_UDMA33_TIMING &&
|
|
offset < (PCI_UDMA33_TIMING + 2)) {
|
|
offset -= PCI_UDMA33_TIMING;
|
|
offset += UDMATIM;
|
|
|
|
if ((offset + size) > (UDMATIM + 2))
|
|
panic("PCI read of UDMATIM with invalid size\n");
|
|
} else {
|
|
panic("PCI read of unimplemented register: %x\n", offset);
|
|
}
|
|
|
|
memcpy((void *)data, (void *)&pci_regs[offset], size);
|
|
}
|
|
|
|
DPRINTF(IdeCtrl, "PCI read offset: %#x (%#x) size: %#x data: %#x\n",
|
|
origOffset, offset, size,
|
|
(*(uint32_t *)data) & (0xffffffff >> 8 * (4 - size)));
|
|
}
|
|
|
|
void
|
|
IdeController::WriteConfig(int offset, int size, uint32_t data)
|
|
{
|
|
DPRINTF(IdeCtrl, "PCI write offset: %#x size: %#x data: %#x\n",
|
|
offset, size, data & (0xffffffff >> 8 * (4 - size)));
|
|
|
|
// do standard write stuff if in standard PCI space
|
|
if (offset < PCI_DEVICE_SPECIFIC) {
|
|
PciDev::WriteConfig(offset, size, data);
|
|
} else {
|
|
if (offset >= PCI_IDE_TIMING && offset < (PCI_IDE_TIMING + 4)) {
|
|
offset -= PCI_IDE_TIMING;
|
|
offset += IDETIM;
|
|
|
|
if ((offset + size) > (IDETIM + 4))
|
|
panic("PCI write to IDETIM with invalid size\n");
|
|
} else if (offset == PCI_SLAVE_TIMING) {
|
|
offset -= PCI_SLAVE_TIMING;
|
|
offset += SIDETIM;
|
|
|
|
if ((offset + size) > (SIDETIM + 1))
|
|
panic("PCI write to SIDETIM with invalid size\n");
|
|
} else if (offset == PCI_UDMA33_CTRL) {
|
|
offset -= PCI_UDMA33_CTRL;
|
|
offset += UDMACTL;
|
|
|
|
if ((offset + size) > (UDMACTL + 1))
|
|
panic("PCI write to UDMACTL with invalid size\n");
|
|
} else if (offset >= PCI_UDMA33_TIMING &&
|
|
offset < (PCI_UDMA33_TIMING + 2)) {
|
|
offset -= PCI_UDMA33_TIMING;
|
|
offset += UDMATIM;
|
|
|
|
if ((offset + size) > (UDMATIM + 2))
|
|
panic("PCI write to UDMATIM with invalid size\n");
|
|
} else {
|
|
panic("PCI write to unimplemented register: %x\n", offset);
|
|
}
|
|
|
|
memcpy((void *)&pci_regs[offset], (void *)&data, size);
|
|
}
|
|
|
|
// Catch the writes to specific PCI registers that have side affects
|
|
// (like updating the PIO ranges)
|
|
switch (offset) {
|
|
case PCI_COMMAND:
|
|
if (config.data[offset] & PCI_CMD_IOSE)
|
|
io_enabled = true;
|
|
else
|
|
io_enabled = false;
|
|
|
|
if (config.data[offset] & PCI_CMD_BME)
|
|
bm_enabled = true;
|
|
else
|
|
bm_enabled = false;
|
|
break;
|
|
|
|
case PCI0_BASE_ADDR0:
|
|
if (BARAddrs[0] != 0) {
|
|
pri_cmd_addr = BARAddrs[0];
|
|
if (pioInterface)
|
|
pioInterface->addAddrRange(RangeSize(pri_cmd_addr,
|
|
pri_cmd_size));
|
|
|
|
pri_cmd_addr &= EV5::PAddrUncachedMask;
|
|
}
|
|
break;
|
|
|
|
case PCI0_BASE_ADDR1:
|
|
if (BARAddrs[1] != 0) {
|
|
pri_ctrl_addr = BARAddrs[1];
|
|
if (pioInterface)
|
|
pioInterface->addAddrRange(RangeSize(pri_ctrl_addr,
|
|
pri_ctrl_size));
|
|
|
|
pri_ctrl_addr &= EV5::PAddrUncachedMask;
|
|
}
|
|
break;
|
|
|
|
case PCI0_BASE_ADDR2:
|
|
if (BARAddrs[2] != 0) {
|
|
sec_cmd_addr = BARAddrs[2];
|
|
if (pioInterface)
|
|
pioInterface->addAddrRange(RangeSize(sec_cmd_addr,
|
|
sec_cmd_size));
|
|
|
|
sec_cmd_addr &= EV5::PAddrUncachedMask;
|
|
}
|
|
break;
|
|
|
|
case PCI0_BASE_ADDR3:
|
|
if (BARAddrs[3] != 0) {
|
|
sec_ctrl_addr = BARAddrs[3];
|
|
if (pioInterface)
|
|
pioInterface->addAddrRange(RangeSize(sec_ctrl_addr,
|
|
sec_ctrl_size));
|
|
|
|
sec_ctrl_addr &= EV5::PAddrUncachedMask;
|
|
}
|
|
break;
|
|
|
|
case PCI0_BASE_ADDR4:
|
|
if (BARAddrs[4] != 0) {
|
|
bmi_addr = BARAddrs[4];
|
|
if (pioInterface)
|
|
pioInterface->addAddrRange(RangeSize(bmi_addr, bmi_size));
|
|
|
|
bmi_addr &= EV5::PAddrUncachedMask;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
Fault
|
|
IdeController::read(MemReqPtr &req, uint8_t *data)
|
|
{
|
|
Addr offset;
|
|
bool primary;
|
|
bool byte;
|
|
bool cmdBlk;
|
|
RegType_t type;
|
|
int disk;
|
|
|
|
parseAddr(req->paddr, offset, primary, type);
|
|
byte = (req->size == sizeof(uint8_t)) ? true : false;
|
|
cmdBlk = (type == COMMAND_BLOCK) ? true : false;
|
|
|
|
if (!io_enabled)
|
|
return No_Fault;
|
|
|
|
// sanity check the size (allows byte, word, or dword access)
|
|
if (req->size != sizeof(uint8_t) && req->size != sizeof(uint16_t) &&
|
|
req->size != sizeof(uint32_t))
|
|
panic("IDE controller read of invalid size: %#x\n", req->size);
|
|
|
|
if (type != BMI_BLOCK) {
|
|
assert(req->size != sizeof(uint32_t));
|
|
|
|
disk = getDisk(primary);
|
|
if (disks[disk])
|
|
disks[disk]->read(offset, byte, cmdBlk, data);
|
|
} else {
|
|
memcpy((void *)data, &bmi_regs[offset], req->size);
|
|
}
|
|
|
|
DPRINTF(IdeCtrl, "read from offset: %#x size: %#x data: %#x\n",
|
|
offset, req->size,
|
|
(*(uint32_t *)data) & (0xffffffff >> 8 * (4 - req->size)));
|
|
|
|
return No_Fault;
|
|
}
|
|
|
|
Fault
|
|
IdeController::write(MemReqPtr &req, const uint8_t *data)
|
|
{
|
|
Addr offset;
|
|
bool primary;
|
|
bool byte;
|
|
bool cmdBlk;
|
|
RegType_t type;
|
|
int disk;
|
|
|
|
parseAddr(req->paddr, offset, primary, type);
|
|
byte = (req->size == sizeof(uint8_t)) ? true : false;
|
|
cmdBlk = (type == COMMAND_BLOCK) ? true : false;
|
|
|
|
DPRINTF(IdeCtrl, "write from offset: %#x size: %#x data: %#x\n",
|
|
offset, req->size,
|
|
(*(uint32_t *)data) & (0xffffffff >> 8 * (4 - req->size)));
|
|
|
|
uint8_t oldVal, newVal;
|
|
|
|
if (!io_enabled)
|
|
return No_Fault;
|
|
|
|
if (type == BMI_BLOCK && !bm_enabled)
|
|
return No_Fault;
|
|
|
|
if (type != BMI_BLOCK) {
|
|
// shadow the dev bit
|
|
if (type == COMMAND_BLOCK && offset == IDE_SELECT_OFFSET) {
|
|
uint8_t *devBit = (primary ? &dev[0] : &dev[1]);
|
|
*devBit = ((*data & IDE_SELECT_DEV_BIT) ? 1 : 0);
|
|
}
|
|
|
|
assert(req->size != sizeof(uint32_t));
|
|
|
|
disk = getDisk(primary);
|
|
if (disks[disk])
|
|
disks[disk]->write(offset, byte, cmdBlk, data);
|
|
} else {
|
|
switch (offset) {
|
|
// Bus master IDE command register
|
|
case BMIC1:
|
|
case BMIC0:
|
|
if (req->size != sizeof(uint8_t))
|
|
panic("Invalid BMIC write size: %x\n", req->size);
|
|
|
|
// select the current disk based on DEV bit
|
|
disk = getDisk(primary);
|
|
|
|
oldVal = bmi_regs[offset];
|
|
newVal = *data;
|
|
|
|
// if a DMA transfer is in progress, R/W control cannot change
|
|
if (oldVal & SSBM) {
|
|
if ((oldVal & RWCON) ^ (newVal & RWCON)) {
|
|
(oldVal & RWCON) ? newVal |= RWCON : newVal &= ~RWCON;
|
|
}
|
|
}
|
|
|
|
// see if the start/stop bit is being changed
|
|
if ((oldVal & SSBM) ^ (newVal & SSBM)) {
|
|
if (oldVal & SSBM) {
|
|
// stopping DMA transfer
|
|
DPRINTF(IdeCtrl, "Stopping DMA transfer\n");
|
|
|
|
// clear the BMIDEA bit
|
|
bmi_regs[offset + 0x2] &= ~BMIDEA;
|
|
|
|
if (disks[disk] == NULL)
|
|
panic("DMA stop for disk %d which does not exist\n",
|
|
disk);
|
|
|
|
// inform the disk of the DMA transfer abort
|
|
disks[disk]->abortDma();
|
|
} else {
|
|
// starting DMA transfer
|
|
DPRINTF(IdeCtrl, "Starting DMA transfer\n");
|
|
|
|
// set the BMIDEA bit
|
|
bmi_regs[offset + 0x2] |= BMIDEA;
|
|
|
|
if (disks[disk] == NULL)
|
|
panic("DMA start for disk %d which does not exist\n",
|
|
disk);
|
|
|
|
// inform the disk of the DMA transfer start
|
|
if (primary)
|
|
disks[disk]->startDma(*(uint32_t *)&bmi_regs[BMIDTP0]);
|
|
else
|
|
disks[disk]->startDma(*(uint32_t *)&bmi_regs[BMIDTP1]);
|
|
}
|
|
}
|
|
|
|
// update the register value
|
|
bmi_regs[offset] = newVal;
|
|
break;
|
|
|
|
// Bus master IDE status register
|
|
case BMIS0:
|
|
case BMIS1:
|
|
if (req->size != sizeof(uint8_t))
|
|
panic("Invalid BMIS write size: %x\n", req->size);
|
|
|
|
oldVal = bmi_regs[offset];
|
|
newVal = *data;
|
|
|
|
// the BMIDEA bit is RO
|
|
newVal |= (oldVal & BMIDEA);
|
|
|
|
// to reset (set 0) IDEINTS and IDEDMAE, write 1 to each
|
|
if ((oldVal & IDEINTS) && (newVal & IDEINTS))
|
|
newVal &= ~IDEINTS; // clear the interrupt?
|
|
else
|
|
(oldVal & IDEINTS) ? newVal |= IDEINTS : newVal &= ~IDEINTS;
|
|
|
|
if ((oldVal & IDEDMAE) && (newVal & IDEDMAE))
|
|
newVal &= ~IDEDMAE;
|
|
else
|
|
(oldVal & IDEDMAE) ? newVal |= IDEDMAE : newVal &= ~IDEDMAE;
|
|
|
|
bmi_regs[offset] = newVal;
|
|
break;
|
|
|
|
// Bus master IDE descriptor table pointer register
|
|
case BMIDTP0:
|
|
case BMIDTP1:
|
|
if (req->size != sizeof(uint32_t))
|
|
panic("Invalid BMIDTP write size: %x\n", req->size);
|
|
|
|
*(uint32_t *)&bmi_regs[offset] = *(uint32_t *)data & ~0x3;
|
|
break;
|
|
|
|
default:
|
|
if (req->size != sizeof(uint8_t) &&
|
|
req->size != sizeof(uint16_t) &&
|
|
req->size != sizeof(uint32_t))
|
|
panic("IDE controller write of invalid write size: %x\n",
|
|
req->size);
|
|
|
|
// do a default copy of data into the registers
|
|
memcpy((void *)&bmi_regs[offset], data, req->size);
|
|
}
|
|
}
|
|
|
|
return No_Fault;
|
|
}
|
|
|
|
////
|
|
// Serialization
|
|
////
|
|
|
|
void
|
|
IdeController::serialize(std::ostream &os)
|
|
{
|
|
// Serialize the PciDev base class
|
|
PciDev::serialize(os);
|
|
|
|
// Serialize register addresses and sizes
|
|
SERIALIZE_SCALAR(pri_cmd_addr);
|
|
SERIALIZE_SCALAR(pri_cmd_size);
|
|
SERIALIZE_SCALAR(pri_ctrl_addr);
|
|
SERIALIZE_SCALAR(pri_ctrl_size);
|
|
SERIALIZE_SCALAR(sec_cmd_addr);
|
|
SERIALIZE_SCALAR(sec_cmd_size);
|
|
SERIALIZE_SCALAR(sec_ctrl_addr);
|
|
SERIALIZE_SCALAR(sec_ctrl_size);
|
|
SERIALIZE_SCALAR(bmi_addr);
|
|
SERIALIZE_SCALAR(bmi_size);
|
|
|
|
// Serialize registers
|
|
SERIALIZE_ARRAY(bmi_regs, 16);
|
|
SERIALIZE_ARRAY(dev, 2);
|
|
SERIALIZE_ARRAY(pci_regs, 8);
|
|
|
|
// Serialize internal state
|
|
SERIALIZE_SCALAR(io_enabled);
|
|
SERIALIZE_SCALAR(bm_enabled);
|
|
SERIALIZE_ARRAY(cmd_in_progress, 4);
|
|
}
|
|
|
|
void
|
|
IdeController::unserialize(Checkpoint *cp, const std::string §ion)
|
|
{
|
|
// Unserialize the PciDev base class
|
|
PciDev::unserialize(cp, section);
|
|
|
|
// Unserialize register addresses and sizes
|
|
UNSERIALIZE_SCALAR(pri_cmd_addr);
|
|
UNSERIALIZE_SCALAR(pri_cmd_size);
|
|
UNSERIALIZE_SCALAR(pri_ctrl_addr);
|
|
UNSERIALIZE_SCALAR(pri_ctrl_size);
|
|
UNSERIALIZE_SCALAR(sec_cmd_addr);
|
|
UNSERIALIZE_SCALAR(sec_cmd_size);
|
|
UNSERIALIZE_SCALAR(sec_ctrl_addr);
|
|
UNSERIALIZE_SCALAR(sec_ctrl_size);
|
|
UNSERIALIZE_SCALAR(bmi_addr);
|
|
UNSERIALIZE_SCALAR(bmi_size);
|
|
|
|
// Unserialize registers
|
|
UNSERIALIZE_ARRAY(bmi_regs, 16);
|
|
UNSERIALIZE_ARRAY(dev, 2);
|
|
UNSERIALIZE_ARRAY(pci_regs, 8);
|
|
|
|
// Unserialize internal state
|
|
UNSERIALIZE_SCALAR(io_enabled);
|
|
UNSERIALIZE_SCALAR(bm_enabled);
|
|
UNSERIALIZE_ARRAY(cmd_in_progress, 4);
|
|
|
|
if (pioInterface) {
|
|
pioInterface->addAddrRange(RangeSize(pri_cmd_addr, pri_cmd_size));
|
|
pioInterface->addAddrRange(RangeSize(pri_ctrl_addr, pri_ctrl_size));
|
|
pioInterface->addAddrRange(RangeSize(sec_cmd_addr, sec_cmd_size));
|
|
pioInterface->addAddrRange(RangeSize(sec_ctrl_addr, sec_ctrl_size));
|
|
pioInterface->addAddrRange(RangeSize(bmi_addr, bmi_size));
|
|
}
|
|
}
|
|
|
|
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
|
|
|
BEGIN_DECLARE_SIM_OBJECT_PARAMS(IdeController)
|
|
|
|
Param<Addr> addr;
|
|
SimObjectVectorParam<IdeDisk *> disks;
|
|
SimObjectParam<MemoryController *> mmu;
|
|
SimObjectParam<PciConfigAll *> configspace;
|
|
SimObjectParam<PciConfigData *> configdata;
|
|
SimObjectParam<Platform *> platform;
|
|
Param<uint32_t> pci_bus;
|
|
Param<uint32_t> pci_dev;
|
|
Param<uint32_t> pci_func;
|
|
SimObjectParam<Bus *> io_bus;
|
|
Param<Tick> pio_latency;
|
|
SimObjectParam<HierParams *> hier;
|
|
|
|
END_DECLARE_SIM_OBJECT_PARAMS(IdeController)
|
|
|
|
BEGIN_INIT_SIM_OBJECT_PARAMS(IdeController)
|
|
|
|
INIT_PARAM(addr, "Device Address"),
|
|
INIT_PARAM(disks, "IDE disks attached to this controller"),
|
|
INIT_PARAM(mmu, "Memory controller"),
|
|
INIT_PARAM(configspace, "PCI Configspace"),
|
|
INIT_PARAM(configdata, "PCI Config data"),
|
|
INIT_PARAM(platform, "Platform pointer"),
|
|
INIT_PARAM(pci_bus, "PCI bus ID"),
|
|
INIT_PARAM(pci_dev, "PCI device number"),
|
|
INIT_PARAM(pci_func, "PCI function code"),
|
|
INIT_PARAM_DFLT(io_bus, "Host bus to attach to", NULL),
|
|
INIT_PARAM_DFLT(pio_latency, "Programmed IO latency in bus cycles", 1),
|
|
INIT_PARAM_DFLT(hier, "Hierarchy global variables", &defaultHierParams)
|
|
|
|
END_INIT_SIM_OBJECT_PARAMS(IdeController)
|
|
|
|
CREATE_SIM_OBJECT(IdeController)
|
|
{
|
|
IdeController::Params *params = new IdeController::Params;
|
|
params->name = getInstanceName();
|
|
params->mmu = mmu;
|
|
params->configSpace = configspace;
|
|
params->configData = configdata;
|
|
params->plat = platform;
|
|
params->busNum = pci_bus;
|
|
params->deviceNum = pci_dev;
|
|
params->functionNum = pci_func;
|
|
|
|
params->disks = disks;
|
|
params->host_bus = io_bus;
|
|
params->pio_latency = pio_latency;
|
|
params->hier = hier;
|
|
return new IdeController(params);
|
|
}
|
|
|
|
REGISTER_SIM_OBJECT("IdeController", IdeController)
|
|
|
|
#endif //DOXYGEN_SHOULD_SKIP_THIS
|