class Riscv(Platform): type = 'Riscv' cxx_header = "dev/riscv/Riscv.hh" system = Param.System(Parent.any, "system") print("Enter Riscv(Platform)") com_1 = Uart8250(pio_addr = 0x80013070) com_1.device = Terminal() def attachIO(self, bus): self.com_1.pio = bus.master
class Malta(Platform): type = 'Malta' cxx_header = "dev/mips/malta.hh" system = Param.System(Parent.any, "system") cchip = MaltaCChip(pio_addr=0x801a0000000) io = MaltaIO(pio_addr=0x801fc000000) uart = Uart8250(pio_addr=0xBFD003F8) # Attach I/O devices to specified bus object. Can't do this # earlier, since the bus object itself is typically defined at the # System level. def attachIO(self, bus): self.cchip.pio = bus.master self.io.pio = bus.master self.uart.pio = bus.master
class Pc(Platform): type = 'Pc' cxx_header = "dev/x86/pc.hh" cxx_class = 'gem5::Pc' system = Param.System(Parent.any, "system") south_bridge = Param.SouthBridge(SouthBridge(), "Southbridge") pci_host = PcPciHost() # Serial port and terminal com_1 = Uart8250() com_1.pio_addr = x86IOAddress(0x3f8) com_1.device = Terminal() # Devices to catch access to non-existant serial ports. fake_com_2 = IsaFake(pio_addr=x86IOAddress(0x2f8), pio_size=8) fake_com_3 = IsaFake(pio_addr=x86IOAddress(0x3e8), pio_size=8) fake_com_4 = IsaFake(pio_addr=x86IOAddress(0x2e8), pio_size=8) # A device to catch accesses to the non-existant floppy controller. fake_floppy = IsaFake(pio_addr=x86IOAddress(0x3f2), pio_size=2) # A bus for accesses not claimed by a specific device. default_bus = IOXBar() # A device to handle accesses to unclaimed IO ports. empty_isa = IsaFake(pio_addr=x86IOAddress(0), pio_size='64KiB', ret_data8=0, ret_data16=0, ret_data32=0, ret_data64=0, pio=default_bus.mem_side_ports) # A device to handle any other type of unclaimed access. bad_addr = BadAddr(pio=default_bus.default) def attachIO(self, bus, dma_ports=[]): self.south_bridge.attachIO(bus, dma_ports) self.com_1.pio = bus.mem_side_ports self.fake_com_2.pio = bus.mem_side_ports self.fake_com_3.pio = bus.mem_side_ports self.fake_com_4.pio = bus.mem_side_ports self.fake_floppy.pio = bus.mem_side_ports self.pci_host.pio = bus.mem_side_ports self.default_bus.cpu_side_ports = bus.default
class Pc(Platform): type = 'Pc' cxx_header = "dev/x86/pc.hh" system = Param.System(Parent.any, "system") south_bridge = SouthBridge() pci_host = PcPciHost() # "Non-existant" ports used for timing purposes by the linux kernel i_dont_exist1 = IsaFake(pio_addr=x86IOAddress(0x80), pio_size=1) i_dont_exist2 = IsaFake(pio_addr=x86IOAddress(0xed), pio_size=1) # Ports behind the pci config and data regsiters. These don't do anything, # but the linux kernel fiddles with them anway. behind_pci = IsaFake(pio_addr=x86IOAddress(0xcf8), pio_size=8) # Serial port and terminal com_1 = Uart8250() com_1.pio_addr = x86IOAddress(0x3f8) com_1.device = Terminal() # Devices to catch access to non-existant serial ports. fake_com_2 = IsaFake(pio_addr=x86IOAddress(0x2f8), pio_size=8) fake_com_3 = IsaFake(pio_addr=x86IOAddress(0x3e8), pio_size=8) fake_com_4 = IsaFake(pio_addr=x86IOAddress(0x2e8), pio_size=8) # A device to catch accesses to the non-existant floppy controller. fake_floppy = IsaFake(pio_addr=x86IOAddress(0x3f2), pio_size=2) # NVMe Interface nvme = NVMeInterface(pci_func=0, pci_dev=5, pci_bus=0) def attachIO(self, bus, dma_ports=[]): self.south_bridge.attachIO(bus, dma_ports) self.i_dont_exist1.pio = bus.master self.i_dont_exist2.pio = bus.master self.behind_pci.pio = bus.master self.com_1.pio = bus.master self.fake_com_2.pio = bus.master self.fake_com_3.pio = bus.master self.fake_com_4.pio = bus.master self.fake_floppy.pio = bus.master self.pci_host.pio = bus.default self.nvme.pio = bus.master if dma_ports.count(self.nvme.dma) == 0: self.nvme.dma = bus.slave
class HiFive(Platform): """HiFive Platform Implementation: This is the base class for SiFive's HiFive board series. It contains the CLINT and PLIC interrupt controllers, Uart and Disk. Implementation details are based on SiFive FU540-C000. https://sifive.cdn.prismic.io/ sifive/b5e7a29c-d3c2-44ea-85fb-acc1df282e2 1_FU540-C000-v1p3.pdf Setup: The following sections outline the required setup for a RISC-V HiFive platform. See configs/example/riscv/fs_linux.py for example. Driving CLINT: CLINT has an interrupt pin which increments mtime. It can be connected to any interrupt source pin which acts as the RTCCLK pin. An abstract RTC wrapper called RiscvRTC can be used. Attaching PLIC devices: PLIC handles external interrupts. Interrupt PioDevices should inherit from PlicIntDevice (PCI and DMA not yet implemented). It contains a parameter interrupt_id which should be used to call platform->postPciInt(id). All PLIC interrupt devices should be returned by _off_chip_devices(). Calling attachPlic sets up the PLIC interrupt source count. Uart: The HiFive platform also has an uart_int_id. This is because Uart8250 uses postConsoleInt instead of postPciInt. In the future if a Uart that inherits PlicIntDevice is implemented, this can be removed. Disk: See fs_linux.py for setup example. PMAChecker: The PMAChecker will be attached to the MMU of each CPU (which allows them to differ). See fs_linux.py for setup example. """ type = 'HiFive' cxx_header = "dev/riscv/hifive.hh" system = Param.System(Parent.any, "system") # CLINT clint = Param.Clint(Clint(pio_addr=0x2000000), "CLINT") # PLIC plic = Param.Plic(Plic(pio_addr=0xc000000), "PLIC") # Uart uart = Uart8250(pio_addr=0x10000000) # Int source ID to redirect console interrupts to # Set to 0 if using a pci interrupt for Uart instead uart_int_id = Param.Int(0xa, "PLIC Uart interrupt ID") terminal = Terminal() # Dummy param for generating devicetree cpu_count = Param.Int(0, "dummy") def _on_chip_devices(self): """Returns a list of on-chip peripherals """ return [self.clint, self.plic] def _off_chip_devices(self): """Returns a list of off-chip peripherals """ devices = [self.uart] if hasattr(self, "disk"): devices.append(self.disk) return devices def _on_chip_ranges(self): """Returns a list of on-chip peripherals address range """ return [ AddrRange(dev.pio_addr, size=dev.pio_size) for dev in self._on_chip_devices() ] def _off_chip_ranges(self): """Returns a list of off-chip peripherals address range """ return [ AddrRange(dev.pio_addr, size=dev.pio_size) for dev in self._off_chip_devices() ] def attachPlic(self): """Count number of PLIC interrupt sources """ plic_srcs = [self.uart_int_id] for device in self._off_chip_devices(): if hasattr(device, "interrupt_id"): plic_srcs.append(device.interrupt_id) self.plic.n_src = max(plic_srcs) + 1 def attachOnChipIO(self, bus): """Attach on-chip IO devices, needs modification to support DMA and PCI """ for device in self._on_chip_devices(): device.pio = bus.mem_side_ports def attachOffChipIO(self, bus): """Attach off-chip IO devices, needs modification to support DMA and PCI """ for device in self._off_chip_devices(): device.pio = bus.mem_side_ports def generateDeviceTree(self, state): cpus_node = FdtNode("cpus") cpus_node.append(FdtPropertyWords("timebase-frequency", [10000000])) yield cpus_node node = FdtNode("soc") local_state = FdtState(addr_cells=2, size_cells=2) node.append(local_state.addrCellsProperty()) node.append(local_state.sizeCellsProperty()) node.append(FdtProperty("ranges")) node.appendCompatible(["simple-bus"]) for subnode in self.recurseDeviceTree(local_state): node.append(subnode) yield node def annotateCpuDeviceNode(self, cpu, state): cpu.append(FdtPropertyStrings('mmu-type', 'riscv,sv48')) cpu.append(FdtPropertyStrings('status', 'okay')) cpu.append(FdtPropertyStrings('riscv,isa', 'rv64imafdcsu')) cpu.appendCompatible(["riscv"]) int_node = FdtNode("interrupt-controller") int_state = FdtState(interrupt_cells=1) int_node.append(int_state.interruptCellsProperty()) int_node.append(FdtProperty("interrupt-controller")) int_node.appendCompatible("riscv,cpu-intc") cpus = self.system.unproxy(self).cpu phandle = int_state.phandle(cpus[self.cpu_count]) self.cpu_count += 1 int_node.append(FdtPropertyWords("phandle", [phandle])) cpu.append(int_node)
class Tsunami(Platform): type = 'Tsunami' cxx_header = "dev/alpha/tsunami.hh" system = Param.System(Parent.any, "system") cchip = TsunamiCChip(pio_addr=0x801a0000000) pchip = TsunamiPChip(pio_addr=0x80180000000) fake_sm_chip = IsaFake(pio_addr=0x801fc000370) fake_uart1 = IsaFake(pio_addr=0x801fc0002f8) fake_uart2 = IsaFake(pio_addr=0x801fc0003e8) fake_uart3 = IsaFake(pio_addr=0x801fc0002e8) fake_uart4 = IsaFake(pio_addr=0x801fc0003f0) fake_ppc = IsaFake(pio_addr=0x801fc0003bb) fake_OROM = IsaFake(pio_addr=0x800000a0000, pio_size=0x60000) fake_pnp_addr = IsaFake(pio_addr=0x801fc000279) fake_pnp_write = IsaFake(pio_addr=0x801fc000a79) fake_pnp_read0 = IsaFake(pio_addr=0x801fc000203) fake_pnp_read1 = IsaFake(pio_addr=0x801fc000243) fake_pnp_read2 = IsaFake(pio_addr=0x801fc000283) fake_pnp_read3 = IsaFake(pio_addr=0x801fc0002c3) fake_pnp_read4 = IsaFake(pio_addr=0x801fc000303) fake_pnp_read5 = IsaFake(pio_addr=0x801fc000343) fake_pnp_read6 = IsaFake(pio_addr=0x801fc000383) fake_pnp_read7 = IsaFake(pio_addr=0x801fc0003c3) fake_ata0 = IsaFake(pio_addr=0x801fc0001f0) fake_ata1 = IsaFake(pio_addr=0x801fc000170) fb = BadDevice(pio_addr=0x801fc0003d0, devicename='FrameBuffer') io = TsunamiIO(pio_addr=0x801fc000000) uart = Uart8250(pio_addr=0x801fc0003f8) backdoor = AlphaBackdoor(pio_addr=0x80200000000, disk=Parent.simple_disk) # Attach I/O devices to specified bus object. Can't do this # earlier, since the bus object itself is typically defined at the # System level. def attachIO(self, bus): self.cchip.pio = bus.master self.pchip.pio = bus.master self.fake_sm_chip.pio = bus.master self.fake_uart1.pio = bus.master self.fake_uart2.pio = bus.master self.fake_uart3.pio = bus.master self.fake_uart4.pio = bus.master self.fake_ppc.pio = bus.master self.fake_OROM.pio = bus.master self.fake_pnp_addr.pio = bus.master self.fake_pnp_write.pio = bus.master self.fake_pnp_read0.pio = bus.master self.fake_pnp_read1.pio = bus.master self.fake_pnp_read2.pio = bus.master self.fake_pnp_read3.pio = bus.master self.fake_pnp_read4.pio = bus.master self.fake_pnp_read5.pio = bus.master self.fake_pnp_read6.pio = bus.master self.fake_pnp_read7.pio = bus.master self.fake_ata0.pio = bus.master self.fake_ata1.pio = bus.master self.fb.pio = bus.master self.io.pio = bus.master self.uart.pio = bus.master self.backdoor.pio = bus.master
class T1000(Platform): type = 'T1000' cxx_header = "dev/sparc/t1000.hh" system = Param.System(Parent.any, "system") fake_clk = IsaFake(pio_addr=0x9600000000, pio_size=0x100000000) #warn_access="Accessing Clock Unit -- Unimplemented!") fake_membnks = IsaFake(pio_addr=0x9700000000, pio_size=16384, ret_data64=0x0000000000000000, update_data=False) #warn_access="Accessing Memory Banks -- Unimplemented!") fake_jbi = IsaFake(pio_addr=0x8000000000, pio_size=0x100000000) #warn_access="Accessing JBI -- Unimplemented!") fake_l2_1 = IsaFake(pio_addr=0xA900000000, pio_size=0x8, ret_data64=0x0000000000000001, update_data=True) #warn_access="Accessing L2 Cache Banks -- Unimplemented!") fake_l2_2 = IsaFake(pio_addr=0xA900000040, pio_size=0x8, ret_data64=0x0000000000000001, update_data=True) #warn_access="Accessing L2 Cache Banks -- Unimplemented!") fake_l2_3 = IsaFake(pio_addr=0xA900000080, pio_size=0x8, ret_data64=0x0000000000000001, update_data=True) #warn_access="Accessing L2 Cache Banks -- Unimplemented!") fake_l2_4 = IsaFake(pio_addr=0xA9000000C0, pio_size=0x8, ret_data64=0x0000000000000001, update_data=True) #warn_access="Accessing L2 Cache Banks -- Unimplemented!") fake_l2esr_1 = IsaFake(pio_addr=0xAB00000000, pio_size=0x8, ret_data64=0x0000000000000000, update_data=True) #warn_access="Accessing L2 ESR Cache Banks -- Unimplemented!") fake_l2esr_2 = IsaFake(pio_addr=0xAB00000040, pio_size=0x8, ret_data64=0x0000000000000000, update_data=True) #warn_access="Accessing L2 ESR Cache Banks -- Unimplemented!") fake_l2esr_3 = IsaFake(pio_addr=0xAB00000080, pio_size=0x8, ret_data64=0x0000000000000000, update_data=True) #warn_access="Accessing L2 ESR Cache Banks -- Unimplemented!") fake_l2esr_4 = IsaFake(pio_addr=0xAB000000C0, pio_size=0x8, ret_data64=0x0000000000000000, update_data=True) #warn_access="Accessing L2 ESR Cache Banks -- Unimplemented!") fake_ssi = IsaFake(pio_addr=0xff00000000, pio_size=0x10000000) #warn_access="Accessing SSI -- Unimplemented!") hterm = Terminal() hvuart = Uart8250(pio_addr=0xfff0c2c000) htod = DumbTOD() pterm = Terminal() puart0 = Uart8250(pio_addr=0x1f10000000) iob = Iob() # Attach I/O devices that are on chip def attachOnChipIO(self, bus): self.iob.pio = bus.master self.htod.pio = bus.master # Attach I/O devices to specified bus object. Can't do this # earlier, since the bus object itself is typically defined at the # System level. def attachIO(self, bus): self.hvuart.device = self.hterm self.puart0.device = self.pterm self.fake_clk.pio = bus.master self.fake_membnks.pio = bus.master self.fake_l2_1.pio = bus.master self.fake_l2_2.pio = bus.master self.fake_l2_3.pio = bus.master self.fake_l2_4.pio = bus.master self.fake_l2esr_1.pio = bus.master self.fake_l2esr_2.pio = bus.master self.fake_l2esr_3.pio = bus.master self.fake_l2esr_4.pio = bus.master self.fake_ssi.pio = bus.master self.fake_jbi.pio = bus.master self.puart0.pio = bus.master self.hvuart.pio = bus.master