Subversion Repositories m32632

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// This file is part of the M32632 project
// http://opencores.org/project,m32632
//
// Filename: DCACHE.v
// Version:  1.0
// Date:     30 May 2015
//
// Copyright (C) 2015 Udo Moeller
// 
// This source file may be used and distributed without 
// restriction provided that this copyright statement is not 
// removed from the file and that any derivative work contains 
// the original copyright notice and the associated disclaimer.
// 
// This source file is free software; you can redistribute it 
// and/or modify it under the terms of the GNU Lesser General 
// Public License as published by the Free Software Foundation;
// either version 2.1 of the License, or (at your option) any 
// later version. 
// 
// This source is distributed in the hope that it will be 
// useful, but WITHOUT ANY WARRANTY; without even the implied 
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
// PURPOSE. See the GNU Lesser General Public License for more 
// details. 
// 
// You should have received a copy of the GNU Lesser General 
// Public License along with this source; if not, download it 
// from http://www.opencores.org/lgpl.shtml 
// 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//	Modules contained in this file:
//	DCACHE		the data cache of M32632
//
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
module DCACHE( 	BCLK, MCLK,	WRCFG, MDONE, BRESET, PTB_WR, PTB_SEL, IO_READY, REG_OUT, PSR_USER, WRIT
				WAMUX, ENWR, IC_PREQ, FILLRAM, CFG, CINVAL, DMA_AA, DP_Q, DRAM_Q, IC_VA, ICTODC, IO_Q, IVAR, MCR
				PACKET, SIZE, VADR,	WADDR, WCTRL, IO_RD, IO_WR, DRAM_ACC, DRAM_WR, INIT_RUN, PTE_STAT, KDET, HLD
				ACC_STAT, DP_DI, DRAM_A, DRAM_DI, IACC_STAT, IC_SIGS, IO_A, IO_BE, IO_DI, KOLLI_A, MMU_DIN, ZTES
				RWVAL, RWVFLAG, DBG_IN, DBG_HIT, ENDRAM );
 
input			BCLK;
input			MCLK;
input			WRCFG;
input			MDONE;
input			BRESET;
input			PTB_WR;
input			PTB_SEL;
input			IO_READY;
input			REG_OUT;
input			PSR_USER;
input			WRITE;
input			READ;
input			ZTEST;
input			RMW;
input			WAMUX;
input			ENWR;
input			IC_PREQ;
input			FILLRAM;
input	 [1:0]	CFG;
input	 [1:0]	CINVAL;
input	[27:4]	DMA_AA;
input	[63:0]	DP_Q;
input	[31:0]	DRAM_Q;
input  [31:12]	IC_VA;
input	 [3:0]	ICTODC;
input	[31:0]	IO_Q;
input	 [1:0]	IVAR;
input	 [3:0]	MCR_FLAGS;
input	 [3:0]	PACKET;
input	 [1:0]	SIZE;
input	[31:0]	VADR;
input	[11:2]	WADDR;
input	 [2:0]	WCTRL;
input	 [2:0]	RWVAL;
input	[40:2]	DBG_IN;
input			ENDRAM;
 
output			IO_RD;
output			IO_WR;
output			DRAM_ACC;
output			DRAM_WR;
output			INIT_RUN;
output	 [1:0]	PTE_STAT;
output			KDET;
output			HLDA;
output			RWVFLAG;
output	 [5:0]	ACC_STAT;
output	[31:0]	DP_DI;
output	 [3:1]	IACC_STAT;
output	 [1:0]	IC_SIGS;
output	[27:4]	KOLLI_A;
output	[23:0]	MMU_DIN;
output reg	[27:0]	DRAM_A;
output reg	[35:0]	DRAM_DI;
output reg	[31:0]	IO_A;
output reg	 [3:0]	IO_BE;
output reg	[31:0]	IO_DI;
output			DBG_HIT;
 
reg		[31:0]	DFFE_IOR;
reg		[31:0]	CAPDAT;
reg		[31:0]	VADR_R;
reg				AUX_ALT;
reg				DFF_QWEXT;
 
wire	[27:4]	ADDR;
wire			ADR_EQU;
wire			AUX_DAT;
wire			CA_HIT;
wire			CA_SET;
wire			CUPDATE;
wire			DMA_MUX;
wire	 [3:0]	ENBYTE;
wire			HIT_ALL;
wire			INIT_CA_RUN;
wire			IO_ACC;
wire			IO_SPACE;
wire			KOMUX;
wire			MMU_HIT;
wire			NEW_PTB;
wire			PTB_ONE;
wire	[27:0]	PTE_ADR;
wire   [31:12]	RADR;
wire	[11:4]	TAGA;
wire	[23:0]	UPDATE_C;
wire	[31:0]	UPDATE_M;
wire			USE_CA;
wire			USER;
wire			WB_ACC;
wire			WEMV;
wire			WR_MRAM;
wire	[31:0]	WRDATA;
wire			VIRT_A;
wire			PTE_MUX;
wire			WE_CV;
wire	[23:0]	DAT_CV;
wire	 [4:0]	WADR_CV;
wire			WRSET0;
wire	 [3:0]	BE_SET;
wire	[31:0]	DAT_SET;
wire	 [9:0]	A_SET;
wire			WRSET1;
wire			SEL_PTB1;
wire			CI;
wire	[27:0]	ADR_MX;
wire			LD_DRAM_A;
wire			VIRTUELL;
wire			NEW_PTB_RUN;
wire			KILL;
wire			LAST_MUX;
wire	[31:0]	SET_DAT;
wire	[31:0]	ALT_DAT;
wire	[31:0]	DAT_MV;
wire	 [3:0]	RADR_MV;
wire	 [3:0]	WADR_MV;
wire	[31:0]	LAST_DAT;
wire			WRCRAM0;
wire			WRCRAM1;
wire			PROT_ERROR;
wire			AUX_QW;
wire			PD_MUX;
wire	[19:0]	PTE_DAT;
wire			PKEEP;
 
// +++++++++++++++++++ Memories ++++++++++++++++++++
 
reg	 	 [7:0]	DATA0_D [0:1023];	// Data Set 0 : 4 kBytes
reg	 	 [7:0]	DATA0_C [0:1023];
reg	 	 [7:0]	DATA0_B [0:1023];
reg	 	 [7:0]	DATA0_A [0:1023];
reg		[31:0]	SET_DAT0;
 
reg	 	 [7:0]	DATA1_D [0:1023];	// Data Set 1 : 4 kBytes
reg	 	 [7:0]	DATA1_C [0:1023];
reg	 	 [7:0]	DATA1_B [0:1023];
reg	 	 [7:0]	DATA1_A [0:1023];
reg		[31:0]	SET_DAT1;
 
reg		[15:0]	TAGSET_0 [0:255];	// Tag Set for Data Set 0 : 256 entries of 16 bits
reg		[15:0]	TAG0;
 
reg		[15:0]	TAGSET_1 [0:255];	// Tag Set for Data Set 1 : 256 entries of 16 bits
reg		[15:0]	TAG1;
 
reg		[23:0]	CA_VALID [0:31];	// Valid bits for Data Set 0 and 1 : 32 entries of 24 bits
reg		[23:0]	CVALID;
 
reg		[35:0]	MMU_TAGS [0:255];	// Tag Set for MMU : 256 entries of 36 bits
reg		[35:0]	MMU_Q;
 
reg		[31:0]	MMU_VALID [0:15];	// Valid bits for MMU Tag Set : 16 entries of 32 bits
reg		[31:0]	MVALID;
 
assign	ADR_EQU	= ({RADR[27:12],VADR_R[11:4]} == DRAM_A[27:4]);	// Limited to 256 MB
 
assign	ALT_DAT	= AUX_ALT ? DFFE_IOR : CAPDAT ;
 
assign	RADR	= VIRT_A ? MMU_Q[19:0] : VADR_R[31:12] ;
 
assign	ADR_MX	= PTE_MUX ? PTE_ADR : {RADR[27:12],VADR_R[11:2],USE_CA,CA_SET} ;
 
assign	KOLLI_A	= DMA_MUX ? DMA_AA : DRAM_A[27:4] ;
 
assign	SET_DAT	= CA_SET ? SET_DAT1 : SET_DAT0 ;
 
assign	VIRT_A	= ~CINVAL[0] & VIRTUELL;
 
assign	USER	= ~MCR_FLAGS[3] & PSR_USER;
 
assign	DAT_SET	= WRITE ? WRDATA : DRAM_Q ;
 
assign	BE_SET 	= ENBYTE | {~WRITE,~WRITE,~WRITE,~WRITE};
 
assign	ADDR	= KOMUX ? KOLLI_A : {RADR[27:12],VADR_R[11:4]} ;
 
assign	A_SET	= WAMUX ? WADDR : VADR_R[11:2] ;
 
assign	TAGA	= KOMUX ? KOLLI_A[11:4] : VADR[11:4] ;
 
assign	INIT_RUN = NEW_PTB_RUN | INIT_CA_RUN;
 
assign	LAST_MUX = AUX_ALT | AUX_DAT | AUX_QW;
 
assign	LAST_DAT = LAST_MUX ? ALT_DAT : SET_DAT ;
 
assign	LD_DRAM_A = ~(DRAM_ACC | PKEEP);
 
assign	ACC_STAT[4] = IO_ACC;
assign	ACC_STAT[5] = CA_HIT;
 
always @(posedge BCLK)
	if (IO_ACC)
		begin
			IO_BE <= ENBYTE;
			IO_DI <= WRDATA;
			IO_A  <= {RADR[31:12],VADR_R[11:0]};
		end
 
always @(posedge BCLK) if (LD_DRAM_A) DRAM_A[27:0] <= ADR_MX[27:0];
 
always @(posedge BCLK) if (IO_RD) DFFE_IOR <= IO_Q;
 
always @(posedge BCLK)
	begin
		DRAM_DI	  <= {(PD_MUX ? PTE_DAT[19:16] : ENBYTE),WRDATA[31:16],
					  (PD_MUX ? PTE_DAT[15:0]  : WRDATA[15:0])};
		AUX_ALT	  <= DFF_QWEXT | IO_RD;
		DFF_QWEXT <= IO_RD & SIZE[0] & SIZE[1];
		VADR_R	  <= VADR;
	end
 
always @(posedge MCLK) if (WCTRL[2]) CAPDAT <= DRAM_Q;
 
// +++++++++++++++++++++++++  Cache Valid  +++++++++++++++++++
 
always @(posedge BCLK) CVALID <= CA_VALID[TAGA[11:7]];
 
always @(negedge BCLK) if (WE_CV) CA_VALID[WADR_CV] <= DAT_CV;
 
// +++++++++++++++++++++++++  Tag Set 0  +++++++++++++++++++++
 
always @(posedge BCLK) TAG0 <= TAGSET_0[TAGA];
 
always @(negedge BCLK) if (WRCRAM0) TAGSET_0[VADR_R[11:4]] <= RADR[27:12];
 
// +++++++++++++++++++++++++  Tag Set 1  +++++++++++++++++++++
 
always @(posedge BCLK) TAG1 <= TAGSET_1[TAGA];
 
always @(negedge BCLK) if (WRCRAM1) TAGSET_1[VADR_R[11:4]] <= RADR[27:12];
 
// +++++++++++++++++++++++++  Data Set 0  ++++++++++++++++++++
 
always @(posedge BCLK)
	begin
		SET_DAT0[31:24]	<= DATA0_D[VADR[11:2]];
		SET_DAT0[23:16]	<= DATA0_C[VADR[11:2]];
		SET_DAT0[15:8]	<= DATA0_B[VADR[11:2]];
		SET_DAT0[7:0]	<= DATA0_A[VADR[11:2]];
	end
 
always @(posedge MCLK)
	if (WRSET0)
		begin
			if (BE_SET[3]) DATA0_D[A_SET] <= DAT_SET[31:24];
			if (BE_SET[2]) DATA0_C[A_SET] <= DAT_SET[23:16];
			if (BE_SET[1]) DATA0_B[A_SET] <= DAT_SET[15:8];
			if (BE_SET[0]) DATA0_A[A_SET] <= DAT_SET[7:0];
		end
 
// +++++++++++++++++++++++++  Data Set 1  ++++++++++++++++++++
 
always @(posedge BCLK)
	begin
		SET_DAT1[31:24]	<= DATA1_D[VADR[11:2]];
		SET_DAT1[23:16]	<= DATA1_C[VADR[11:2]];
		SET_DAT1[15:8]	<= DATA1_B[VADR[11:2]];
		SET_DAT1[7:0]	<= DATA1_A[VADR[11:2]];
	end
 
always @(posedge MCLK)
	if (WRSET1)
		begin
			if (BE_SET[3]) DATA1_D[A_SET] <= DAT_SET[31:24];
			if (BE_SET[2]) DATA1_C[A_SET] <= DAT_SET[23:16];
			if (BE_SET[1]) DATA1_B[A_SET] <= DAT_SET[15:8];
			if (BE_SET[0]) DATA1_A[A_SET] <= DAT_SET[7:0];
		end
 
DCACHE_SM	DC_SM(
	.BCLK(BCLK),
	.BRESET(BRESET),
	.VIRTUELL(VIRTUELL),
	.IO_SPACE(IO_SPACE),
	.MDONE(MDONE),
	.MMU_HIT(MMU_HIT),
	.CA_HIT(CA_HIT),
	.READ(READ),
	.WRITE(WRITE),
	.ZTEST(ZTEST),
	.RMW(RMW),
	.USE_CA(USE_CA),
	.PTB_WR(PTB_WR),
	.PTB_SEL(PTB_SEL),
	.SEL_PTB1(SEL_PTB1),
	.IO_READY(IO_READY),
	.USER(USER),
	.PROTECT(ACC_STAT[3]),
	.PROT_ERROR(PROT_ERROR),
	.ENWR(ENWR),
	.WB_ACC(WB_ACC),
	.ADR_EQU(ADR_EQU),
	.IC_PREQ(IC_PREQ),
	.CAPDAT(CAPDAT[31:0]),
	.CPU_OUT(DP_Q[59:44]),
	.FILLRAM(FILLRAM),
	.IC_VA(IC_VA),
	.ICTODC(ICTODC),
	.VADR_R(VADR_R[31:12]),
	.NEW_PTB(NEW_PTB),
	.PTB_ONE(PTB_ONE),
	.DRAM_ACC(DRAM_ACC),
	.DRAM_WR(DRAM_WR),
	.IO_ACC(IO_ACC),
	.IO_RD(IO_RD),
	.IO_WR(IO_WR),
	.PTE_STAT(PTE_STAT),
	.ABORT(ACC_STAT[1]),
	.WR_MRAM(WR_MRAM),
	.CUPDATE(CUPDATE),
	.AUX_DAT(AUX_DAT),
	.PTE_MUX(PTE_MUX),
	.ACC_OK(ACC_STAT[0]),
	.ABO_LEVEL1(ACC_STAT[2]),
	.IACC_STAT(IACC_STAT),
	.KOMUX(KOMUX),
	.KDET(KDET),
	.HIT_ALL(HIT_ALL),
	.DMA_MUX(DMA_MUX),
	.HLDA(HLDA),
	.RWVAL(RWVAL[1:0]),
	.RWVFLAG(RWVFLAG),
	.IC_SIGS(IC_SIGS),
	.MMU_DIN(MMU_DIN),
	.PD_MUX(PD_MUX),
	.PKEEP(PKEEP),
	.PTE_ADR(PTE_ADR),
	.PTE_DAT(PTE_DAT));
 
CA_MATCH	DCA_COMPARE(
	.INVAL_L(CINVAL[0]),
	.CI(CI),
	.MMU_HIT(MMU_HIT),
	.WRITE(WRITE),
	.KDET(KDET),
	.ADDR(ADDR),
	.CFG(CFG),
	.ENDRAM(ENDRAM),
	.CVALID(CVALID),
	.TAG0(TAG0),
	.TAG1(TAG1),
	.CA_HIT(CA_HIT),
	.CA_SET(CA_SET),
	.WB_ACC(WB_ACC),
	.USE_CA(USE_CA),
	.IOSEL(RADR[31:28]),
	.IO_SPACE(IO_SPACE),
	.KILL(KILL),
	.DC_ILO(RWVAL[2]),
	.UPDATE(UPDATE_C));
 
DCA_CONTROL	DCA_CTRL(
	.BCLK(BCLK),
	.MCLK(MCLK),
	.BRESET(BRESET),
	.CA_SET(CA_SET),
	.HIT_ALL(HIT_ALL),
	.UPDATE(UPDATE_C),
	.VADR_R(ADDR[11:7]),
	.DRAM_ACC(DRAM_ACC),
	.CUPDATE(CUPDATE),
	.KILL(KILL),
	.WRITE(WRITE),
	.WRCFG(WRCFG),
	.WCTRL(WCTRL[1:0]),
	.INVAL_A(CINVAL[1]),
	.DAT_CV(DAT_CV),
	.WADR_CV(WADR_CV),
	.WE_CV(WE_CV),
	.INIT_CA_RUN(INIT_CA_RUN),
	.WRCRAM0(WRCRAM0),
	.WRCRAM1(WRCRAM1),
	.WRSET0(WRSET0),
	.WRSET1(WRSET1));
 
MMU_MATCH	MMU_COMPARE(
	.USER(USER),
	.WRITE(WRITE),
	.READ(READ),
	.RMW(RMW),
	.IVAR(IVAR),
	.MCR_FLAGS(MCR_FLAGS[2:0]),
	.MMU_VA(MMU_Q[35:20]),
	.MVALID(MVALID),
	.VADR_R(VADR_R[31:12]),
	.MMU_HIT(MMU_HIT),
	.PROT_ERROR(PROT_ERROR),
	.VIRTUELL(VIRTUELL),
	.CI(CI),
	.SEL_PTB1(SEL_PTB1),
	.UPDATE(UPDATE_M));
 
MMU_UP	MMU_CTRL(
	.BCLK(BCLK),
	.BRESET(BRESET),
	.NEW_PTB(NEW_PTB),
	.IVAR(IVAR[1]),
	.PTB1(PTB_ONE),
	.WR_MRAM(WR_MRAM),
	.MVALID(MVALID),
	.UPDATE(UPDATE_M),
	.VADR(VADR[19:16]),
	.VADR_R(VADR_R[19:16]),
	.WE_MV(WEMV),
	.NEW_PTB_RUN(NEW_PTB_RUN),
	.DAT_MV(DAT_MV),
	.RADR_MV(RADR_MV),
	.WADR_MV(WADR_MV));
 
// +++++++++++++++++++++++++  MMU Valid  +++++++++++++++++++++
 
always @(posedge BCLK) MVALID <= MMU_VALID[RADR_MV];
 
always @(negedge BCLK) if (WEMV) MMU_VALID[WADR_MV] <= DAT_MV;
 
// +++++++++++++++++++++++++  MMU Tags  ++++++++++++++++++++++
 
always @(posedge BCLK) MMU_Q <= MMU_TAGS[VADR[19:12]];
 
always @(negedge BCLK) if (WR_MRAM) MMU_TAGS[VADR_R[19:12]] <= {VADR_R[31:20],MMU_DIN[23:0]};
 
RD_ALIGNER	RD_ALI(
	.BCLK(BCLK),
	.ACC_OK(ACC_STAT[0]),
	.REG_OUT(REG_OUT),
	.PACKET(PACKET),
	.RDDATA(LAST_DAT),
	.SIZE(SIZE),
	.CA_HIT(CA_HIT),
	.DP_DI(DP_DI),
	.AUX_QW(AUX_QW));
 
WR_ALIGNER	WR_ALI(
	.DP_Q(DP_Q),
	.PACKET(PACKET),
	.SIZE(SIZE),
	.ENBYTE(ENBYTE),
	.WRDATA(WRDATA));
 
DEBUG_AE DBGAE(
	.DBG_IN(DBG_IN),
	.READ(READ),
	.WRITE(WRITE),
	.USER(USER),
	.VIRTUELL(VIRTUELL),
	.ACC_OK(ACC_STAT[0]),
	.VADR_R(VADR_R[31:2]),
	.MMU_Q(MMU_Q[19:0]),
	.ENBYTE(ENBYTE),
	.DBG_HIT(DBG_HIT));
 
endmodule