mirror of https://github.com/zellyn/go6502.git
566 lines
13 KiB
Go
566 lines
13 KiB
Go
package visual
|
|
|
|
import (
|
|
icpu "github.com/zellyn/go6502/cpu" // Just need the interface
|
|
)
|
|
|
|
type cpu struct {
|
|
m icpu.Memory
|
|
cycle uint64
|
|
|
|
nodes uint // number of nodes
|
|
transistors uint // number of transistors
|
|
|
|
vss uint
|
|
vcc uint
|
|
|
|
nodesPullup bitmap
|
|
nodesPulldown bitmap
|
|
nodesValue bitmap
|
|
nodeGates [][]uint // the list of transistor indexes attached to a node
|
|
nodeC1C2s [][]uint // the list of transistor c1/c2s attached to a node
|
|
nodeDependents [][]uint // all C1 and C2 nodes of transistors attached to a node
|
|
nodeLeftDependents [][]uint // TODO(zellyn): doc
|
|
|
|
transistorsGate []uint
|
|
transistorsC1 []uint
|
|
transistorsC2 []uint
|
|
transistorsOn bitmap
|
|
|
|
listIn []uint // the nodes we are working with
|
|
listOut []uint // the indirect nodes we are collecting for the next run
|
|
listOutBitmap bitmap
|
|
|
|
group []uint
|
|
groupBitmap bitmap
|
|
groupContainsValue groupContains
|
|
}
|
|
|
|
type groupContains uint8
|
|
|
|
const (
|
|
CONTAINS_NOTHING groupContains = iota
|
|
CONTAINS_HI
|
|
CONTAINS_PULLUP
|
|
CONTAINS_PULLDOWN
|
|
CONTAINS_VCC
|
|
CONTAINS_VSS
|
|
)
|
|
|
|
// // The lookup table for the group value. If vss is in the group, it's 0, vcc makes it 1, etc.
|
|
// // vss, vcc, pulldown, pullup, hi
|
|
// var GroupValues = [32]byte{
|
|
// 0, // 00000 - nothing
|
|
// 1, // 00001 - contains at least one hi node
|
|
// 1, // 00010 - contains at least one pullup
|
|
// 1, // 00011 - contains at least one pullup
|
|
// 0, // 00100 - contains at least one pulldown
|
|
// 0, // 00101 - contains at least one pulldown
|
|
// 0, // 00110 - contains at least one pulldown
|
|
// 0, // 00111 - contains at least one pulldown
|
|
// 1, // 01000 - contains vcc
|
|
// 1, // 01001 - contains vcc
|
|
// 1, // 01010 - contains vcc
|
|
// 1, // 01011 - contains vcc
|
|
// 1, // 01100 - contains vcc
|
|
// 1, // 01101 - contains vcc
|
|
// 1, // 01110 - contains vcc
|
|
// 1, // 01111 - contains vcc
|
|
// 0, // 10000- contains vss
|
|
// 0, // 10001- contains vss
|
|
// 0, // 10010- contains vss
|
|
// 0, // 10011- contains vss
|
|
// 0, // 10100- contains vss
|
|
// 0, // 10101- contains vss
|
|
// 0, // 10110- contains vss
|
|
// 0, // 10111- contains vss
|
|
// 0, // 11000- contains vss
|
|
// 0, // 11001- contains vss
|
|
// 0, // 11010- contains vss
|
|
// 0, // 11011- contains vss
|
|
// 0, // 11100- contains vss
|
|
// 0, // 11101- contains vss
|
|
// 0, // 11110- contains vss
|
|
// 0, // 11111- contains vss
|
|
// }
|
|
|
|
func NewCPU(memory icpu.Memory) icpu.Cpu {
|
|
c := cpu{m: memory}
|
|
c.setupNodesAndTransistors(TransDefs, SegDefs, NODE_vss, NODE_vcc)
|
|
return &c
|
|
}
|
|
|
|
// Needed for the interface. Not really practical. I guess we could try changing the nodes directly.
|
|
func (c *cpu) SetPC(uint16) {
|
|
panic("Not implemented")
|
|
}
|
|
|
|
/************************************/
|
|
/* Interfacing and extracting state */
|
|
/************************************/
|
|
|
|
func (c *cpu) Read8(n0, n1, n2, n3, n4, n5, n6, n7 uint) byte {
|
|
return (c.nodeBit(n0) | c.nodeBit(n1)<<1 | c.nodeBit(n2)<<2 | c.nodeBit(n3)<<3 |
|
|
c.nodeBit(n4)<<4 | c.nodeBit(n5)<<5 | c.nodeBit(n6)<<6 | c.nodeBit(n7)<<7)
|
|
}
|
|
|
|
func (c *cpu) AddressBus() uint16 {
|
|
abl := uint16(c.Read8(NODE_ab0, NODE_ab1, NODE_ab2, NODE_ab3, NODE_ab4, NODE_ab5, NODE_ab6, NODE_ab7))
|
|
abh := uint16(c.Read8(NODE_ab8, NODE_ab9, NODE_ab10, NODE_ab11, NODE_ab12, NODE_ab13, NODE_ab14, NODE_ab15))
|
|
return abl + abh<<8
|
|
}
|
|
|
|
func (c *cpu) DataBus() byte {
|
|
return c.Read8(NODE_db0, NODE_db1, NODE_db2, NODE_db3, NODE_db4, NODE_db5, NODE_db6, NODE_db7)
|
|
}
|
|
|
|
func (c *cpu) A() byte {
|
|
return c.Read8(NODE_a0, NODE_a1, NODE_a2, NODE_a3, NODE_a4, NODE_a5, NODE_a6, NODE_a7)
|
|
}
|
|
|
|
func (c *cpu) X() byte {
|
|
return c.Read8(NODE_x0, NODE_x1, NODE_x2, NODE_x3, NODE_x4, NODE_x5, NODE_x6, NODE_x7)
|
|
}
|
|
|
|
func (c *cpu) Y() byte {
|
|
return c.Read8(NODE_y0, NODE_y1, NODE_y2, NODE_y3, NODE_y4, NODE_y5, NODE_y6, NODE_y7)
|
|
}
|
|
|
|
func (c *cpu) P() byte {
|
|
return c.Read8(NODE_p0, NODE_p1, NODE_p2, NODE_p3, NODE_p4, NODE_p5, NODE_p6, NODE_p7)
|
|
}
|
|
|
|
func (c *cpu) SP() byte {
|
|
return c.Read8(NODE_s0, NODE_s1, NODE_s2, NODE_s3, NODE_s4, NODE_s5, NODE_s6, NODE_s7)
|
|
}
|
|
|
|
func (c *cpu) IR() byte {
|
|
return c.Read8(NODE_notir0, NODE_notir1, NODE_notir2, NODE_notir3, NODE_notir4,
|
|
NODE_notir5, NODE_notir6, NODE_notir7) ^ 0xFF
|
|
}
|
|
|
|
func (c *cpu) PCL() byte {
|
|
return c.Read8(NODE_pcl0, NODE_pcl1, NODE_pcl2, NODE_pcl3, NODE_pcl4, NODE_pcl5, NODE_pcl6, NODE_pcl7)
|
|
}
|
|
|
|
func (c *cpu) PCH() byte {
|
|
return c.Read8(NODE_pch0, NODE_pch1, NODE_pch2, NODE_pch3, NODE_pch4, NODE_pch5, NODE_pch6, NODE_pch7)
|
|
}
|
|
|
|
func (c *cpu) PC() uint16 {
|
|
return uint16(c.PCH())<<8 + uint16(c.PCL())
|
|
}
|
|
|
|
func (c *cpu) nodeBit(n uint) byte {
|
|
if c.getNodeValue(n) {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (c *cpu) writeDataBus(d byte) {
|
|
for i := 0; i < 8; i++ {
|
|
c.setNode(DataBusNodes[i], d&1 == 1)
|
|
d >>= 1
|
|
}
|
|
}
|
|
|
|
func (c *cpu) Reset() {
|
|
c.setNode(NODE_res, false)
|
|
c.setNode(NODE_clk0, true)
|
|
c.setNode(NODE_rdy, true)
|
|
c.setNode(NODE_so, false)
|
|
c.setNode(NODE_irq, true)
|
|
c.setNode(NODE_nmi, true)
|
|
|
|
c.stabilizeChip()
|
|
|
|
// Hold RESET for 8 cycles
|
|
for i := 0; i < 8; i++ {
|
|
c.Step()
|
|
}
|
|
|
|
c.setNode(NODE_res, true)
|
|
c.recalcNodeList()
|
|
|
|
c.cycle = 0
|
|
}
|
|
|
|
// handleMemory is called when clk0 is low, and either reads from or
|
|
// writes to memory, depending on rw.
|
|
func (c *cpu) handleMemory() {
|
|
if c.isNodeHigh(NODE_rw) {
|
|
c.writeDataBus(c.m.Read(c.AddressBus()))
|
|
} else {
|
|
c.m.Write(c.AddressBus(), c.DataBus())
|
|
}
|
|
}
|
|
|
|
// HalfStep is the main clock loop, and takes a half clock step.
|
|
func (c *cpu) HalfStep() {
|
|
clk := c.isNodeHigh(NODE_clk0)
|
|
/* invert clock */
|
|
c.setNode(NODE_clk0, !clk)
|
|
c.recalcNodeList()
|
|
|
|
if !clk {
|
|
c.handleMemory()
|
|
}
|
|
c.cycle++
|
|
}
|
|
|
|
// Step takes two half steps.
|
|
func (c *cpu) Step() error {
|
|
c.HalfStep()
|
|
c.HalfStep()
|
|
return nil
|
|
}
|
|
|
|
/************************/
|
|
/* Algorithms for Nodes */
|
|
/************************/
|
|
|
|
/*
|
|
* The "value" propertiy of VCC and GND is never evaluated in the code,
|
|
* so we don't bother initializing it properly or special-casing writes.
|
|
*/
|
|
|
|
func (c *cpu) setNodePullup(t uint, s bool) {
|
|
c.nodesPullup.set(t, s)
|
|
}
|
|
|
|
func (c *cpu) getNodePullup(t uint) bool {
|
|
return c.nodesPullup.get(t)
|
|
}
|
|
|
|
func (c *cpu) setNodePulldown(t uint, s bool) {
|
|
c.nodesPulldown.set(t, s)
|
|
}
|
|
|
|
func (c *cpu) getNodePulldown(t uint) bool {
|
|
return c.nodesPulldown.get(t)
|
|
}
|
|
|
|
func (c *cpu) setNodeValue(t uint, s bool) {
|
|
c.nodesValue.set(t, s)
|
|
}
|
|
|
|
func (c *cpu) getNodeValue(t uint) bool {
|
|
return c.nodesValue.get(t)
|
|
}
|
|
|
|
/******************************/
|
|
/* Algorithms for Transistors */
|
|
/******************************/
|
|
|
|
func (c *cpu) setTransistorOn(t uint, s bool) {
|
|
c.transistorsOn.set(t, s)
|
|
}
|
|
|
|
func (c *cpu) getTransistorOn(t uint) bool {
|
|
return c.transistorsOn.get(t)
|
|
}
|
|
|
|
/************************/
|
|
/* Algorithms for Lists */
|
|
/************************/
|
|
|
|
func (c *cpu) switchLists() {
|
|
c.listIn, c.listOut = c.listOut, c.listIn
|
|
}
|
|
|
|
func (c *cpu) clearListOut() {
|
|
c.listOut = c.listOut[:0]
|
|
c.listOutBitmap.clear()
|
|
}
|
|
|
|
func (c *cpu) listOutAdd(i uint) {
|
|
if !c.listOutBitmap.get(i) {
|
|
c.listOut = append(c.listOut, i)
|
|
c.listOutBitmap.set(i, true)
|
|
}
|
|
}
|
|
|
|
/**********************************/
|
|
/* Algorithms for Groups of Nodes */
|
|
/**********************************/
|
|
|
|
/*
|
|
* a group is a set of connected nodes, which consequently
|
|
* share the same value
|
|
*
|
|
* we use an array and a count for O(1) insert and
|
|
* iteration, and a redundant bitmap for O(1) lookup
|
|
*/
|
|
|
|
func (c *cpu) groupClear() {
|
|
c.group = c.group[:0]
|
|
c.groupBitmap.clear()
|
|
}
|
|
|
|
func (c *cpu) groupAdd(i uint) {
|
|
c.group = append(c.group, i)
|
|
c.groupBitmap.set(i, true)
|
|
}
|
|
|
|
func (c *cpu) groupContains(el uint) bool {
|
|
return c.groupBitmap.get(el)
|
|
}
|
|
|
|
func (c *cpu) groupCount() uint {
|
|
return uint(len(c.group))
|
|
}
|
|
|
|
/*********************************/
|
|
/* Node and Transistor Emulation */
|
|
/*********************************/
|
|
|
|
func (c *cpu) addNodeToGroup(n uint) {
|
|
/*
|
|
* We need to stop at vss and vcc, otherwise we'll revisit other groups
|
|
* with the same value - just because they all derive their value from
|
|
* the fact that they are connected to vcc or vss.
|
|
*/
|
|
|
|
if n == c.vss {
|
|
c.groupContainsValue = CONTAINS_VSS
|
|
return
|
|
}
|
|
|
|
if n == c.vcc {
|
|
if c.groupContainsValue != CONTAINS_VSS {
|
|
c.groupContainsValue = CONTAINS_VCC
|
|
}
|
|
return
|
|
}
|
|
|
|
if c.groupContains(n) {
|
|
return
|
|
}
|
|
|
|
c.groupAdd(n)
|
|
|
|
if c.groupContainsValue < CONTAINS_PULLDOWN && c.getNodePulldown(n) {
|
|
c.groupContainsValue = CONTAINS_PULLDOWN
|
|
}
|
|
|
|
if c.groupContainsValue < CONTAINS_PULLUP && c.getNodePullup(n) {
|
|
c.groupContainsValue = CONTAINS_PULLUP
|
|
}
|
|
|
|
if c.groupContainsValue < CONTAINS_HI && c.getNodeValue(n) {
|
|
c.groupContainsValue = CONTAINS_HI
|
|
}
|
|
|
|
/* revisit all transistors that control this node */
|
|
for _, tn := range c.nodeC1C2s[n] {
|
|
/* if the transistor connects c1 and c2... */
|
|
if c.getTransistorOn(uint(tn)) {
|
|
/* if original node was connected to c1, continue with c2 */
|
|
if c.transistorsC1[tn] == n {
|
|
c.addNodeToGroup(c.transistorsC2[tn])
|
|
} else {
|
|
c.addNodeToGroup(c.transistorsC1[tn])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *cpu) addAllNodesToGroup(node uint) {
|
|
c.groupClear()
|
|
c.groupContainsValue = CONTAINS_NOTHING
|
|
c.addNodeToGroup(node)
|
|
}
|
|
|
|
func (c *cpu) getGroupValue() bool {
|
|
switch c.groupContainsValue {
|
|
case CONTAINS_VCC, CONTAINS_PULLUP, CONTAINS_HI:
|
|
return true
|
|
case CONTAINS_VSS, CONTAINS_PULLDOWN, CONTAINS_NOTHING:
|
|
return false
|
|
}
|
|
panic("cannot get here")
|
|
}
|
|
|
|
func (c *cpu) recalcNode(node uint) {
|
|
/*
|
|
* get all nodes that are connected through
|
|
* transistors, starting with this one
|
|
*/
|
|
c.addAllNodesToGroup(node)
|
|
|
|
/* get the state of the group */
|
|
newv := c.getGroupValue()
|
|
|
|
/*
|
|
* - set all nodes to the group state
|
|
* - check all transistors switched by nodes of the group
|
|
* - collect all nodes behind toggled transistors
|
|
* for the next run
|
|
*/
|
|
for _, nn := range c.group {
|
|
if c.getNodeValue(nn) != newv {
|
|
c.setNodeValue(nn, newv)
|
|
for _, tn := range c.nodeGates[nn] {
|
|
c.setTransistorOn(tn, newv)
|
|
}
|
|
|
|
if newv {
|
|
for _, dp := range c.nodeLeftDependents[nn] {
|
|
c.listOutAdd(dp)
|
|
}
|
|
} else {
|
|
for _, dp := range c.nodeDependents[nn] {
|
|
c.listOutAdd(dp)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *cpu) recalcNodeList() {
|
|
for j := 0; j < 100; j++ { /* loop limiter */
|
|
/*
|
|
* make the secondary list our primary list, use
|
|
* the data storage of the primary list as the
|
|
* secondary list
|
|
*/
|
|
c.switchLists()
|
|
|
|
if len(c.listIn) == 0 {
|
|
break
|
|
}
|
|
|
|
c.clearListOut()
|
|
|
|
/*
|
|
* for all nodes, follow their paths through
|
|
* turned-on transistors, find the state of the
|
|
* path and assign it to all nodes, and re-evaluate
|
|
* all transistors controlled by this path, collecting
|
|
* all nodes that changed because of it for the next run
|
|
*/
|
|
for _, n := range c.listIn {
|
|
c.recalcNode(n)
|
|
}
|
|
}
|
|
c.clearListOut()
|
|
}
|
|
|
|
/******************/
|
|
/* Initialization */
|
|
/******************/
|
|
|
|
func (c *cpu) addNodeDependent(a uint, b uint) {
|
|
for _, dp := range c.nodeDependents[a] {
|
|
if dp == b {
|
|
return
|
|
}
|
|
}
|
|
c.nodeDependents[a] = append(c.nodeDependents[a], b)
|
|
}
|
|
|
|
func (c *cpu) addNodeLeftDependent(a uint, b uint) {
|
|
for _, dp := range c.nodeLeftDependents[a] {
|
|
if dp == b {
|
|
return
|
|
}
|
|
}
|
|
c.nodeLeftDependents[a] = append(c.nodeLeftDependents[a], b)
|
|
}
|
|
|
|
func (c *cpu) setupNodesAndTransistors(transDefs []TransDef, nodeIsPullup []bool, vss uint, vcc uint) {
|
|
c.nodes = uint(len(nodeIsPullup))
|
|
c.transistors = uint(len(transDefs))
|
|
c.vss = vss
|
|
c.vcc = vcc
|
|
c.nodesPullup = newBitmap(c.nodes)
|
|
c.nodesPulldown = newBitmap(c.nodes)
|
|
c.nodesValue = newBitmap(c.nodes)
|
|
|
|
c.transistorsOn = newBitmap(c.transistors)
|
|
c.listOutBitmap = newBitmap(c.nodes)
|
|
c.groupBitmap = newBitmap(c.nodes)
|
|
|
|
c.nodeGates = make([][]uint, c.transistors)
|
|
c.nodeC1C2s = make([][]uint, c.transistors)
|
|
c.nodeDependents = make([][]uint, c.nodes, c.nodes)
|
|
c.nodeLeftDependents = make([][]uint, c.nodes, c.nodes)
|
|
|
|
/* copy nodes into r/w data structure */
|
|
for i, isPullup := range nodeIsPullup {
|
|
c.setNodePullup(uint(i), isPullup)
|
|
}
|
|
|
|
/* copy transistors into r/w data structure */
|
|
for _, transDef := range transDefs {
|
|
found := false
|
|
for j2, gate := range c.transistorsGate {
|
|
if gate == transDef.gate &&
|
|
((c.transistorsC1[j2] == transDef.c1 && c.transistorsC2[j2] == transDef.c2) ||
|
|
(c.transistorsC1[j2] == transDef.c2 && c.transistorsC2[j2] == transDef.c1)) {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
c.transistorsGate = append(c.transistorsGate, transDef.gate)
|
|
c.transistorsC1 = append(c.transistorsC1, transDef.c1)
|
|
c.transistorsC2 = append(c.transistorsC2, transDef.c2)
|
|
}
|
|
}
|
|
|
|
/* cross reference transistors in nodes data structures */
|
|
for i, gate := range c.transistorsGate {
|
|
c1 := c.transistorsC1[i]
|
|
c2 := c.transistorsC2[i]
|
|
c.nodeGates[gate] = append(c.nodeGates[gate], uint(i))
|
|
c.nodeC1C2s[c1] = append(c.nodeC1C2s[c1], uint(i))
|
|
c.nodeC1C2s[c2] = append(c.nodeC1C2s[c2], uint(i))
|
|
}
|
|
|
|
for i := uint(0); i < c.nodes; i++ {
|
|
for _, t := range c.nodeGates[i] {
|
|
c1 := c.transistorsC1[t]
|
|
if c1 != vss && c1 != vcc {
|
|
c.addNodeDependent(i, c1)
|
|
}
|
|
c2 := c.transistorsC2[t]
|
|
if c2 != vss && c2 != vcc {
|
|
c.addNodeDependent(i, c2)
|
|
}
|
|
if c1 != vss && c1 != vcc {
|
|
c.addNodeLeftDependent(i, c1)
|
|
} else {
|
|
c.addNodeLeftDependent(i, c2)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *cpu) Print(bool) {
|
|
panic("not implemented")
|
|
}
|
|
|
|
func (c *cpu) stabilizeChip() {
|
|
for i := uint(0); i < c.nodes; i++ {
|
|
c.listOutAdd(i)
|
|
}
|
|
c.recalcNodeList()
|
|
}
|
|
|
|
/**************/
|
|
/* Node State */
|
|
/**************/
|
|
|
|
func (c *cpu) setNode(nn uint, s bool) {
|
|
c.setNodePullup(nn, s)
|
|
c.setNodePulldown(nn, !s)
|
|
c.listOutAdd(nn)
|
|
c.recalcNodeList()
|
|
}
|
|
|
|
func (c *cpu) isNodeHigh(nn uint) bool {
|
|
return c.getNodeValue(nn)
|
|
}
|