b7b8ffa7b7
interrupts.
dev/sinic.cc:
- The prepareRead function sets all the variables in the register
file that depend on various state bits that change on the fly.
Includes RxDone, RxWait, TxDone, and TxWait
- Use the new register information accessor functions to grab
validity and size information for the read and write functions
- read all registers directly from the register space by offset
and size, not by actual name (less code)
- The side effect of reading the interrupt status (clearing it) now
happens outside the actual chunk of code where the value is loaded.
- Add an iprRead function for when we may want speculative access
to device registers through an ipr or special instruction.
- When RxData or TxData are written, their busy flag is set to
indicate that they have an outstanding transaction.
- The RxHigh and TxLow interrupts are special, they only interrupt
if the rxEmpty or txFull limits were hit
- Move reset to the command register
- Update more registers on reset, clear rxEmpty and txFull
- Data dumps only happen if EthernetData trace flag set
- When a DMA completes, kick the other engine if it was waiting
- implement all of the new interrupts
- serialize the new stuff
dev/sinic.hh:
- Put all registers with their proper size and alignment into
the regs struct so that we can copy multiple at a time.
- Provide accessor functions for accessing the registers with
different sizes.
- Flags to track when the rx fifo hit empty and the tx fifo became
full. These flags are used to determine what to do when below
the watermarks, and are reset when crossing the watermark.
- the txDmaEvent should actually trigger the txDmaDone function
- Add an iprRead function for when we may want speculative access
to device registers through an ipr or special instruction.
- The prepareRead function sets all the variables in the register
file that depend on various state bits that change on the fly.
- add rx_max_intr and dedicated (for dedicated thread) config params
dev/sinicreg.hh:
Add some new registers: Command, RxMaxIntr, RxFifoSize, TxFifoSize,
rename XxThreshold to XxFifoMark
Move Reset to the Command register
Add Thread to the Config register
New interrupts, better names
More info in RxDone and TxDone
Easier access to information on each register (size, read, write, name)
python/m5/objects/Ethernet.py:
Both sinic and nsgige have the dedicated thread
Add a parameter to configure the maximum number for receive
packets per interrupt
--HG--
extra : convert_revision : 407c5a993b6fb17326b4c623ee5d4b25fd69ac80
111 lines
4.3 KiB
Python
111 lines
4.3 KiB
Python
from m5 import *
|
|
from Device import DmaDevice
|
|
from Pci import PciDevice
|
|
|
|
class EtherInt(SimObject):
|
|
type = 'EtherInt'
|
|
abstract = True
|
|
peer = Param.EtherInt(NULL, "peer interface")
|
|
|
|
class EtherLink(SimObject):
|
|
type = 'EtherLink'
|
|
int1 = Param.EtherInt("interface 1")
|
|
int2 = Param.EtherInt("interface 2")
|
|
delay = Param.Latency('0us', "packet transmit delay")
|
|
speed = Param.NetworkBandwidth('1Gbps', "link speed")
|
|
dump = Param.EtherDump(NULL, "dump object")
|
|
|
|
class EtherBus(SimObject):
|
|
type = 'EtherBus'
|
|
loopback = Param.Bool(True, "send packet back to the sending interface")
|
|
dump = Param.EtherDump(NULL, "dump object")
|
|
speed = Param.NetworkBandwidth('100Mbps', "bus speed in bits per second")
|
|
|
|
class EtherTap(EtherInt):
|
|
type = 'EtherTap'
|
|
bufsz = Param.Int(10000, "tap buffer size")
|
|
dump = Param.EtherDump(NULL, "dump object")
|
|
port = Param.UInt16(3500, "tap port")
|
|
|
|
class EtherDump(SimObject):
|
|
type = 'EtherDump'
|
|
file = Param.String("dump file")
|
|
maxlen = Param.Int(96, "max portion of packet data to dump")
|
|
|
|
if build_env['ALPHA_TLASER']:
|
|
|
|
class EtherDev(DmaDevice):
|
|
type = 'EtherDev'
|
|
hardware_address = Param.EthernetAddr(NextEthernetAddr,
|
|
"Ethernet Hardware Address")
|
|
|
|
dma_data_free = Param.Bool(False, "DMA of Data is free")
|
|
dma_desc_free = Param.Bool(False, "DMA of Descriptors is free")
|
|
dma_read_delay = Param.Latency('0us', "fixed delay for dma reads")
|
|
dma_read_factor = Param.Latency('0us', "multiplier for dma reads")
|
|
dma_write_delay = Param.Latency('0us', "fixed delay for dma writes")
|
|
dma_write_factor = Param.Latency('0us', "multiplier for dma writes")
|
|
dma_no_allocate = Param.Bool(True, "Should we allocate cache on read")
|
|
|
|
rx_filter = Param.Bool(True, "Enable Receive Filter")
|
|
rx_delay = Param.Latency('1us', "Receive Delay")
|
|
tx_delay = Param.Latency('1us', "Transmit Delay")
|
|
|
|
intr_delay = Param.Latency('0us', "Interrupt Delay")
|
|
payload_bus = Param.Bus(NULL, "The IO Bus to attach to for payload")
|
|
physmem = Param.PhysicalMemory(Parent.any, "Physical Memory")
|
|
tlaser = Param.Turbolaser(Parent.any, "Turbolaser")
|
|
|
|
class EtherDevInt(EtherInt):
|
|
type = 'EtherDevInt'
|
|
device = Param.EtherDev("Ethernet device of this interface")
|
|
|
|
class EtherDevBase(PciDevice):
|
|
hardware_address = Param.EthernetAddr(NextEthernetAddr,
|
|
"Ethernet Hardware Address")
|
|
|
|
clock = Param.Clock('0ns', "State machine processor frequency")
|
|
|
|
physmem = Param.PhysicalMemory(Parent.any, "Physical Memory")
|
|
|
|
hier = Param.HierParams(Parent.any, "Hierarchy global variables")
|
|
payload_bus = Param.Bus(NULL, "The IO Bus to attach to for payload")
|
|
dma_read_delay = Param.Latency('0us', "fixed delay for dma reads")
|
|
dma_read_factor = Param.Latency('0us', "multiplier for dma reads")
|
|
dma_write_delay = Param.Latency('0us', "fixed delay for dma writes")
|
|
dma_write_factor = Param.Latency('0us', "multiplier for dma writes")
|
|
dma_no_allocate = Param.Bool(True, "Should we allocate cache on read")
|
|
|
|
rx_delay = Param.Latency('1us', "Receive Delay")
|
|
tx_delay = Param.Latency('1us', "Transmit Delay")
|
|
rx_fifo_size = Param.MemorySize('512kB', "max size of rx fifo")
|
|
tx_fifo_size = Param.MemorySize('512kB', "max size of tx fifo")
|
|
|
|
rx_filter = Param.Bool(True, "Enable Receive Filter")
|
|
intr_delay = Param.Latency('10us', "Interrupt Propagation Delay")
|
|
dedicated = Param.Bool(False, "dedicate a kernel thread to the driver")
|
|
|
|
class NSGigE(EtherDevBase):
|
|
type = 'NSGigE'
|
|
|
|
dma_data_free = Param.Bool(False, "DMA of Data is free")
|
|
dma_desc_free = Param.Bool(False, "DMA of Descriptors is free")
|
|
|
|
|
|
class NSGigEInt(EtherInt):
|
|
type = 'NSGigEInt'
|
|
device = Param.NSGigE("Ethernet device of this interface")
|
|
|
|
class Sinic(EtherDevBase):
|
|
type = 'Sinic'
|
|
|
|
rx_max_copy = Param.MemorySize('1514B', "rx max copy")
|
|
tx_max_copy = Param.MemorySize('16kB', "tx max copy")
|
|
rx_max_intr = Param.UInt32(10, "max rx packets per interrupt")
|
|
rx_fifo_threshold = Param.MemorySize('48kB', "rx fifo high threshold")
|
|
tx_fifo_threshold = Param.MemorySize('16kB', "tx fifo low threshold")
|
|
|
|
class SinicInt(EtherInt):
|
|
type = 'SinicInt'
|
|
device = Param.Sinic("Ethernet device of this interface")
|