dmacontroller.java

JPC: x86 PC Hardware Emulator. 牛津大学开发的一个纯JAVA的x86系统结构硬件模拟器。

	    val = mask;
	    break;
	default:
	    val = 0;
	    break;
	}
	return val;
    }
    private int readPage(int portNumber)
    {
	int channelNumber = channels[portNumber & 7];
	if (-1 == channelNumber) {
	    return 0;
	}
	return 0xff & dmaRegs[channelNumber].page;
    }
    private int readPageH(int portNumber)
    {
	int channelNumber = channels[portNumber & 7];
	if (-1 == channelNumber) {
	    return 0;
	}
	return 0xff & dmaRegs[channelNumber].pageh;
    }
    public void ioPortWriteByte(int address, int data)
    {
	switch ((address - iobase) >>> dShift) {
	case 0x0:
	case 0x1:
	case 0x2:
	case 0x3:
	case 0x4:
	case 0x5:
	case 0x6:
	case 0x7:
	    writeChannel(address, data);
	    return;
	case 0x8:
	case 0x9:
	case 0xa:
	case 0xb:
	case 0xc:
	case 0xd:
	case 0xe:
	case 0xf:
	    writeController(address, data);
	    return;
	default:
	    break;
	}
	
	switch (address - pageBase) {
	case pagePortList0:
	case pagePortList1:
	case pagePortList2:
	case pagePortList3:
	    writePage(address, data);
	    return;
	default:
	    break;
	}
	switch (address - pageHBase) {
	case pagePortList0:
	case pagePortList1:
	case pagePortList2:
	case pagePortList3:
	    writePageH(address, data);
	    return;
	default:
	    break;
	}
    }
    public void ioPortWriteWord(int address, int data)
    {
	this.ioPortWriteByte(address, data);
	this.ioPortWriteByte(address + 1, data >>> 8);
    }
    public void ioPortWriteLong(int address, int data)
    {
	this.ioPortWriteWord(address, data);
	this.ioPortWriteWord(address + 2, data >>> 16);
    }

    public int ioPortReadByte(int address)
    {
	switch ((address - iobase) >>> dShift) {
	case 0x0:
	case 0x1:
	case 0x2:
	case 0x3:
	case 0x4:
	case 0x5:
	case 0x6:
	case 0x7:
	    return readChannel(address);
	case 0x8:
	case 0x9:
	case 0xa:
	case 0xb:
	case 0xc:
	case 0xd:
	case 0xe:
	case 0xf:
	    return readController(address);
	default:
	    break;
	}

	switch (address - pageBase) {
	case pagePortList0:
	case pagePortList1:
	case pagePortList2:
	case pagePortList3:
	    return readPage(address);
	default:
	    break;
	}
	switch (address - pageHBase) {
	case pagePortList0:
	case pagePortList1:
	case pagePortList2:
	case pagePortList3:
	    return readPageH(address);
	default:
	    break;
	}
	return 0xff;
    }
    public int ioPortReadWord(int address)
    {
	return (0xff & this.ioPortReadByte(address)) | ((this.ioPortReadByte(address) << 8) & 0xff);
    }
    public int ioPortReadLong(int address)
    {
	return (0xffff & this.ioPortReadByte(address)) | ((this.ioPortReadByte(address) << 16) & 0xffff);
    }

    public int[] ioPortsRequested()
    {
	int[] temp;
	if (pageHBase >= 0) {
	    temp = new int[16 + (2*pagePortList.length)];
	} else {
	    temp = new int[16 + pagePortList.length];
	}

	int j = 0;
	for (int i = 0; i < 8; i++) {
	    temp[j++] = iobase + (i << this.dShift);
	}
	for (int i = 0; i < pagePortList.length; i++) {
	    temp[j++] = pageBase + pagePortList[i];
	    if (pageHBase >= 0) {
		temp[j++] = pageHBase + pagePortList[i];
	    }
	}
	for (int i = 0; i < 8; i++) {
	    temp[j++] = iobase + ((i + 8) << this.dShift);
	}
	return temp;
    }

    private boolean getFlipFlop()
    {
	boolean ff = flipFlop;
	flipFlop = !ff;
	return ff;
    }
    private void initChannel(int channelNumber)
    {
	DMARegister r = dmaRegs[channelNumber];
	r.nowAddress = (0xffff & r.baseAddress) << dShift;
	r.nowCount = 0;
    }

    public void runTransfers()
    {
	int value = ~mask & (status >>> 4) & 0xf;
	if (value == 0)
	    return;

	while (value != 0) {
	    int channelNumber = Integer.numberOfTrailingZeros(value);
	    if (channelNumber < 4)
		runChannel(channelNumber);
	    else 
		break;
	    value &= ~(1 << channelNumber);
	}

// 	for(int channelNumber = 0; channelNumber < 4; channelNumber++) {
// 	    int mask = 1 << channelNumber;
// 	    if ((0 == (this.mask & mask)) && (0 != (this.status & (mask << 4))))
// 		runChannel(channelNumber);
// 	}
    }

    private void runChannel(int channelNumber)
    {
	DMARegister r = dmaRegs[channelNumber];
	int n = r.transferDevice.transferHandler(channelNumber + (controllerNumber << 2), r.nowCount, (r.baseCount + 1) << controllerNumber);
	r.nowCount = n;
    }

    public int getChannelMode(int channelNumber)
    {
	return dmaRegs[channelNumber].mode;
    }

    public void holdDREQ(int channelNumber)
    {
	status |= 1 << (channelNumber + 4);
	runTransfers();
    }

    public void releaseDREQ(int channelNumber)
    {
	status &= ~(1 << (channelNumber + 4));
    }

    public void registerChannel(int channelNumber, DMATransferCapable device)
    {
	dmaRegs[channelNumber].transferDevice = device;
    }

    public int readMemory(int channelNumber, byte[] buffer, int bufferOffset, int position, int length)
    {
	DMARegister r = dmaRegs[channelNumber];

	long address = ((r.pageh & 0x7fl) << 24) |
	    ((0xffl & r.page) << 16) |
	    (0xffffffffl & r.nowAddress);

	if ((r.mode & 0x20) != 0) {
	    System.err.println("DMA Read In Address Decrement Mode!");
	    //This may be broken for 16bit DMA
	    memory.copyContentsInto((int)(address - position - length), buffer, bufferOffset, length);
	    //Should have really decremented address with each byte read, so instead just reverse array order
	    for (int left = bufferOffset, right = bufferOffset + length - 1; left < right; left++, right--) {
		byte temp = buffer[left];
		buffer[left] = buffer[right];
		buffer[right] = temp; // exchange the first and last
	    }
	} else
	    memory.copyContentsInto((int)(address + position), buffer, bufferOffset, length);

	return length;

    }

    public int writeMemory(int channelNumber, byte[] buffer, int bufferOffset, int position, int length)
    {
	DMARegister r = dmaRegs[channelNumber];
	long address = ((0x7fl & r.pageh) << 24) | ((0xffl & r.page) << 16) | (0xffffffffl & r.nowAddress);

	if ((r.mode & 0x20) != 0) {
	    System.err.println("DMA Write In Address Decrement Mode!");
	    //This may be broken for 16bit DMA
	    //Should really decremented address with each byte write, so instead we reverse the array order now
	    for (int left = bufferOffset, right = bufferOffset + length - 1; left < right; left++, right--) {
		byte temp = buffer[left];
		buffer[left] = buffer[right];
		buffer[right] = temp; // exchange the first and last
	    }
	    memory.copyContentsFrom((int)(address - position - length), buffer, bufferOffset, length);
	} else
	    memory.copyContentsFrom((int)(address + position), buffer, bufferOffset, length);

	return length;
    }

    private boolean ioportRegistered;

    public boolean initialised()
    {
	return ((memory != null) && ioportRegistered);
    }

    public boolean updated()
    {
	return memory.updated() && ioportRegistered;
    }

    public void acceptComponent(HardwareComponent component)
    {
	if (component instanceof PhysicalAddressSpace)
	    this.memory = (PhysicalAddressSpace)component;
	if (component instanceof IOPortHandler) {
	    ((IOPortHandler)component).registerIOPortCapable(this);
	    ioportRegistered = true;
	}
    }

    public void updateComponent(HardwareComponent component)
    {
	if (component instanceof IOPortHandler) 
        {
	    ((IOPortHandler)component).registerIOPortCapable(this);
	    ioportRegistered = true;
	}
    }

    public void timerCallback() {}

    public String toString()
    {
	return "DMA Controller [element " + dShift + "]";
    }
}