OpenCores
URL https://opencores.org/ocsvn/sdhc-sc-core/sdhc-sc-core/trunk

Subversion Repositories sdhc-sc-core

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /
    from Rev 144 to Rev 145
    ↔ Reverse comparison
  •

Rev 144 → Rev 145

/sdhc-sc-core/trunk/src/grpSd/unitSdCardModel/src/SdBFM.sv
0,0 → 1,126
//
// file: SdBFM.sv
// author: Rainer Kastl
//
// Bus functional model for SD bus
//
`ifndef SDBFM_SV
`define SDBFM_SV
 
`include "SdCmdInterface.sv"
`include "Crc.sv"
`include "Logger.sv"
`include "SDCommandArg.sv"
 
const logic cSdStartbit = 0;
const logic cSdEndbit = 1;
 
typedef logic SdBusTransData[$];
 
virtual class SdBusTrans;
virtual function SdBusTransData packToData();
endfunction
 
virtual function void unpackFromData(ref SdBusTransData data);
endfunction
endclass
 
class SdBusTransToken extends SdBusTrans;
logic transbit;
logic[5:0] id;
SDCommandArg arg;
aCrc7 crc;
 
function aCrc7 calcCrcOfToken();
logic temp[$] = { >> { cSdStartbit, this.transbit, this.id, this.arg}};
return calcCrc7(temp);
endfunction
 
virtual function SdBusTransData packToData();
SdBusTransData data = { >> {transbit, id, arg, crc}};
return data;
endfunction
virtual function void unpackFromData(ref SdBusTransData data);
{ >> {transbit, id, arg, crc}} = data;
endfunction
 
endclass;
 
class SdBFM;
 
virtual ISdCard.card ICard;
local semaphore sem;
local Logger log;
 
function new(virtual ISdCard card);
this.ICard = card;
this.log = new;
this.sem = new(1);
 
// disable outputs
ICard.cb.Cmd <= 'z;
ICard.cb.Data <= 'z;
endfunction
 
task send(input SdBusTrans token);
this.sem.get(1);
// startbit
@ICard.cb;
ICard.cb.Cmd <= cSdStartbit;
 
// data
begin
SdBusTransData data = token.packToData();
 
foreach(data[i]) begin
@ICard.cb;
ICard.cb.Cmd <= data[i];
end
data.delete();
end
 
// endbit
@ICard.cb;
ICard.cb.Cmd <= cSdEndbit;
 
@ICard.cb;
ICard.cb.Cmd <= 'z;
 
this.sem.put(1);
endtask
 
task receive(output SdBusTransToken token);
this.sem.get(1);
token = new();
 
wait(ICard.cb.Cmd == cSdStartbit);
// data
begin
SdBusTransData data;
 
for (int i = 0; i < 46; i++) begin
@ICard.cb;
data.push_back(ICard.cb.Cmd);
end
 
token.unpackFromData(data);
end
 
// endbit
@ICard.cb;
assert(ICard.cb.Cmd == cSdEndbit) else
begin
this.log.error("Received invalid endbit during SdBFM.receive.\n");
end
 
this.sem.put(1);
endtask
 
endclass
 
`endif
/sdhc-sc-core/trunk/src/grpSd/unitSdCardModel/src/SdData.sv
36,20 → 36,20
data.push_back(crc[i]);
endfunction
 
task automatic recv(virtual ISdCard.Card ICard, ref logic rddata[$]);
task automatic recv(virtual ISdCard.card ICard, ref logic rddata[$]);
aCrc16 crc[4];
ICard.cbcard.Data <= 'bzzzz;
ICard.cb.Data <= 'bzzzz;
 
if (mode == wide) begin
 
// startbits
wait(ICard.cbcard.Data == 'b0000);
wait(ICard.cb.Data == 'b0000);
$display("Startbits: %t", $time);
for (int j = 0; j < 512*2; j++) begin
@ICard.cbcard;
@ICard.cb;
for(int i = 0; i < 4; i++) begin
rddata.push_back(ICard.cbcard.Data[i]);
rddata.push_back(ICard.cb.Data[i]);
end
end
 
56,24 → 56,22
// crc
for (int j = 0; j < 16; j++) begin
@ICard.cbcard;
@ICard.cb;
for(int i = 0; i < 4; i++) begin
crc[i] = ICard.cbcard.Data[i];
crc[i] = ICard.cb.Data[i];
end
end
 
// end bits
@ICard.cbcard;
$display("Endbits: %h, %t", ICard.cbcard.Data, $time);
assert(ICard.cbcard.Data == 'b1111);
@ICard.cb;
$display("Endbits: %h, %t", ICard.cb.Data, $time);
assert(ICard.cb.Data == 'b1111);
 
$display("%b", ICard.cbcard.Data);
 
end
 
endtask
 
task automatic send(virtual ISdCard.Card ICmd, logic data[$]);
task automatic send(virtual ISdCard.card ICmd, logic data[$]);
aCrc16 crc = 0;
 
this.data = data;
84,13 → 82,13
data.push_back(1); // endbit
foreach(data[i]) begin
@ICmd.cbcard;
ICmd.cbcard.Data[0] <= data[i];
@ICmd.cb;
ICmd.cb.Data[0] <= data[i];
end
 
data = {};
@ICmd.cbcard;
ICmd.cbcard.Data <= 'z;
@ICmd.cb;
ICmd.cb.Data <= 'z;
end
else begin
logic dat0[$];
109,19 → 107,19
CrcOnContainer(dat2);
CrcOnContainer(dat3);
 
@ICmd.cbcard;
ICmd.cbcard.Data = 0;
@ICmd.cb;
ICmd.cb.Data <= 0;
 
for(int i = 0; i < dat0.size(); i++) begin
@ICmd.cbcard;
ICmd.cbcard.Data <= (dat3[i]<<3) + (dat2[i] <<2) + (dat1[i] <<1) + dat0[i];
@ICmd.cb;
ICmd.cb.Data <= (dat3[i]<<3) + (dat2[i] <<2) + (dat1[i] <<1) + dat0[i];
end
@ICmd.cbcard;
ICmd.cbcard.Data = 0;
@ICmd.cb;
ICmd.cb.Data <= 0;
 
@ICmd.cbcard;
ICmd.cbcard.Data <= 'z;
@ICmd.cb;
ICmd.cb.Data <= 'z;
end
endtask
 
/sdhc-sc-core/trunk/src/grpSd/unitSdCardModel/src/SdCardModel.sv
14,16 → 14,18
`include "Crc.sv";
`include "SdCommand.sv";
`include "SdData.sv";
`include "SdBFM.sv";
`include "Logger.sv";
 
class SDCard;
local virtual ISdCard.Card ICard;
 
local SdBFM bfm;
local virtual ISdCard.card ICard;
local SDCardState state;
local RCA_t rca;
local SDCommandToken recvcmd;
local logic CCS;
local Mode_t mode;
local DataMode_t datamode;
local Logger log;
 
local event CmdReceived, InitDone;
 
31,9 → 33,14
constraint cdatasize {datasize > 1; datasize <= 32;}
 
local logic[512*8-1:0] ram[];
function void post_randomize() ;
this.ram = new[2^(datasize-1)];
endfunction
 
function new(virtual ISdCard CardInterface, event CmdReceived, event InitDone);
ICard = CardInterface;
bfm = new(CardInterface);
state = new();
this.CmdReceived = CmdReceived;
this.InitDone = InitDone;
40,54 → 47,12
this.CCS = 1;
rca = 0;
mode = standard;
ICard.cbcard.Data <= 'z;
log = new();
endfunction
 
task reset();
endtask
 
// Receive a command token and handle it
task recv();
ICard.cbcard.Cmd <= 'z;
 
repeat(8) @ICard.cbcard;
 
recvcmd = new();
 
wait(ICard.cbcard.Cmd == 0);
// Startbit
recvcmd.startbit = ICard.cbcard.Cmd;
 
@ICard.cbcard;
// Transbit
recvcmd.transbit = ICard.cbcard.Cmd;
 
// CmdID
for (int i = 5; i >= 0; i--) begin
@ICard.cbcard;
recvcmd.id[i] = ICard.cbcard.Cmd;
end
 
// Arg
for (int i = 31; i >= 0; i--) begin
@ICard.cbcard;
recvcmd.arg[i] = ICard.cbcard.Cmd;
end
 
// CRC
for (int i = 6; i >= 0; i--) begin
@ICard.cbcard;
recvcmd.crc7[i] = ICard.cbcard.Cmd;
end
 
// Endbit
@ICard.cbcard;
recvcmd.endbit = ICard.cbcard.Cmd;
 
recvcmd.checkFromHost();
-> CmdReceived;
endtask
 
task automatic init();
SDCommandR7 voltageresponse;
SDCommandR1 response;
97,85 → 62,105
SDCommandR6 rcaresponse;
logic data[$];
SdData sddata;
SdBusTransToken token;
 
// create ram
ram = new[2^(datasize-1)];
log.note("Expecting CMD0");
// expect CMD0 so that state is clear
recv();
assert(recvcmd.id == cSdCmdGoIdleState);
this.bfm.receive(token);
assert(token.id == cSdCmdGoIdleState) else log.error("Received invalid token.");
// expect CMD8: voltage and SD 2.00 compatible
recv();
assert(recvcmd.id == cSdCmdSendIfCond);
assert(recvcmd.arg[12:8] == 'b0001); // Standard voltage
log.note("Expecting CMD8");
this.bfm.receive(token);
assert(token.id == cSdCmdSendIfCond) else log.error("Received invalid token.");
assert(token.arg[12:8] == 'b0001) else
begin
string msg;
$swrite(msg, "Received invalid arg: %b", token.arg);
log.error(msg); // Standard voltage
end;
 
// respond with R7: we are SD 2.00 compatible and compatible to the
// voltage
voltageresponse = new(recvcmd.arg);
voltageresponse.send(ICard);
voltageresponse = new(token.arg);
this.bfm.send(voltageresponse);
 
recvCMD55(0);
 
// expect ACMD41 with HCS = 1
recv();
assert(recvcmd.id == cSdCmdACMD41);
assert(recvcmd.arg == cSdArgACMD41HCS);
log.note("Expect ACMD41 (with HCS = 1)");
this.bfm.receive(token);
assert(token.id == cSdCmdACMD41) else log.error("Received invalid token.\n");
assert(token.arg == cSdArgACMD41HCS) else begin
string msg;
$swrite(msg, "Received invalid arg: %b, Expected: %b", token.arg, cSdArgACMD41HCS);
log.error(msg);
end;
state.AppCmd = 0;
 
// respond with R3
// respond with R3, not done
ocr = new(CCS, cSdVoltageWindow);
acmd41response = new(ocr);
acmd41response.send(ICard);
this.bfm.send(acmd41response);
recvCMD55(0);
 
// expect ACMD41 with HCS = 1
recv();
assert(recvcmd.id == cSdCmdACMD41);
assert(recvcmd.arg == cSdArgACMD41HCS);
log.note("Expect ACMD41 (with HCS = 1)");
this.bfm.receive(token);
assert(token.id == cSdCmdACMD41) else log.error("Received invalid token.\n");
assert(token.arg == cSdArgACMD41HCS) else begin
string msg;
$swrite(msg, "Received invalid arg: %b, Expected: %b", token.arg, cSdArgACMD41HCS);
log.error(msg);
end;
state.AppCmd = 0;
 
// respond with R3
ocr.setBusy(cOCRDone);
acmd41response = new(ocr);
acmd41response.send(ICard);
this.bfm.send(acmd41response);
 
// expect CMD2
recv();
assert(recvcmd.id == cSdCmdAllSendCID);
log.note("Expect CMD2");
this.bfm.receive(token);
assert(token.id == cSdCmdAllSendCID) else log.error("Received invalid token.\n");
 
// respond with R2
cidresponse = new();
cidresponse.send(ICard);
this.bfm.send(cidresponse);
 
// expect CMD3
recv();
assert(recvcmd.id == cSdCmdSendRelAdr);
log.note("Expect CMD3");
this.bfm.receive(token);
assert(token.id == cSdCmdSendRelAdr) else log.error("Received invalid token.\n");
 
// respond with R3
rcaresponse = new(rca, state);
rcaresponse.send(ICard);
this.bfm.send(rcaresponse);
 
// expect CMD7
recv();
assert(recvcmd.id == cSdCmdSelCard);
assert(recvcmd.arg[31:16] == rca);
log.note("Expect CMD7");
this.bfm.receive(token);
assert(token.id == cSdCmdSelCard);
assert(token.arg[31:16] == rca);
 
// respond with R1, no busy
state.ReadyForData = 1;
response = new(cSdCmdSelCard, state);
response.send(ICard);
this.bfm.send(response);
 
// expect ACMD51
recvCMD55(rca);
recv();
assert(recvcmd.id == cSdCmdSendSCR);
log.note("Expect ACMD51");
this.bfm.receive(token);
assert(token.id == cSdCmdSendSCR);
 
// respond with R1
response = new(cSdCmdSendSCR, state);
response.send(ICard);
this.bfm.send(response);
 
repeat(2) @ICard.cbcard;
repeat(2) @ICard.cb;
 
// send dummy SCR
for (int i = 0; i < 64; i++)
189,21 → 174,23
 
// expect ACMD6
recvCMD55(rca);
recv();
assert(recvcmd.id == cSdCmdSetBusWidth);
assert(recvcmd.arg == 'h00000002);
log.note("Expect ACMD6");
this.bfm.receive(token);
assert(token.id == cSdCmdSetBusWidth);
assert(token.arg == 'h00000002);
 
response = new(cSdCmdSetBusWidth, state);
response.send(ICard);
this.bfm.send(response);
 
sddata.mode = wide;
mode = wide;
 
// expect CMD6
recv();
assert(recvcmd.id == cSdCmdSwitchFuntion);
assert(recvcmd.arg == 'h00FFFFF1);
response.send(ICard);
log.note("Expect CMD6");
this.bfm.receive(token);
assert(token.id == cSdCmdSwitchFuntion);
assert(token.arg == 'h00FFFFF1);
this.bfm.send(response);
 
// send status data structure
data = {};
216,10 → 203,11
sddata.send(ICard, data);
 
// expect CMD6 with set
recv();
assert(recvcmd.id == cSdCmdSwitchFuntion);
assert(recvcmd.arg == 'h80FFFFF1);
response.send(ICard);
log.note("Expect CMD6 with set");
this.bfm.receive(token);
assert(token.id == cSdCmdSwitchFuntion);
assert(token.arg == 'h80FFFFF1);
this.bfm.send(response);
 
// send status data structure
data = {};
233,11 → 221,12
 
// switch to 50MHz
// expect CMD13
recv();
assert(recvcmd.id == cSdCmdSendStatus);
assert(recvcmd.arg == rca);
log.note("Expect CMD13");
this.bfm.receive(token);
assert(token.id == cSdCmdSendStatus);
assert(token.arg == rca);
response = new(cSdCmdSendStatus, state);
response.send(ICard);
this.bfm.send(response);
 
-> InitDone;
 
248,14 → 237,15
logic data[$];
logic[31:0] addr;
SdData sddata = new(mode, usual);
SdBusTransToken token;
 
// expect Read
recv();
assert(recvcmd.id == cSdCmdReadSingleBlock);
addr = recvcmd.arg;
this.bfm.receive(token);
assert(token.id == cSdCmdReadSingleBlock);
addr = token.arg[0];
assert(addr < ram.size());
response = new(cSdCmdReadSingleBlock, state);
response.send(ICard);
this.bfm.send(response);
 
data = {};
for (int i = 0; i < 512; i++) begin
272,14 → 262,15
SdData sddata = new(this.mode, widewidth);
logic rddata[$];
logic[31:0] addr;
SdBusTransToken token;
 
// expect Write
recv();
assert(recvcmd.id == cSdCmdWriteSingleBlock);
addr = recvcmd.arg;
this.bfm.receive(token);
assert(token.id == cSdCmdWriteSingleBlock);
addr = token.arg[0];
assert(addr < ram.size());
response = new(cSdCmdWriteSingleBlock, state);
response.send(ICard);
this.bfm.send(response);
 
// recv data
sddata.recv(ICard, rddata);
301,22 → 292,19
 
task recvCMD55(RCA_t rca);
SDCommandR1 response;
SdBusTransToken token;
// expect CMD55
recv();
assert(recvcmd.id == cSdCmdNextIsACMD);
assert(recvcmd.arg[31:16] == rca);
this.bfm.receive(token);
assert(token.id == cSdCmdNextIsACMD);
assert(token.arg[31:16] == rca);
state.recvCMD55();
 
// respond with R1
response = new(cSdCmdNextIsACMD, state);
response.send(ICard);
this.bfm.send(response);
endtask
function automatic SDCommandToken getCmd();
return recvcmd;
endfunction
 
endclass
 
class NoSDCard extends SDCard;
/sdhc-sc-core/trunk/src/grpSd/unitSdCardModel/src/SdCommand.sv
12,6 → 12,7
`include "SdCardState.sv";
`include "SDCID.sv";
`include "SDOCR.sv";
`include "SdBFM.sv";
 
typedef logic[15:0] RCA_t;
 
40,203 → 41,89
 
const SDCommandArg cSdArgACMD41HCS = 'b01000000111111111000000000000000;
 
class SDCommandToken;
logic startbit;
logic transbit;
rand logic[5:0] id;
rand SDCommandArg arg;
aCrc7 crc7;
logic endbit;
typedef logic[5:0] SdCommandId;
const logic cSdTransbitToHost = 0;
 
function void display();
$display("Startbit: %b", startbit);
$display("Transbit: %b", transbit);
$display("ID: %b", id);
$display("Arg: %h", arg);
$display("CRC: %b", crc7);
$display("Endbit: %b" , endbit);
endfunction
class DefaultSdResponse extends SdBusTransToken;
 
function void checkStartEnd();
assert(startbit == 0);
assert(endbit == 1);
function new(SdCommandId id, SDCommandArg arg);
this.transbit = cSdTransbitToHost;
this.id = id;
this.arg = arg;
this.crc = calcCrcOfToken();
endfunction
function void checkFromHost();
checkStartEnd();
checkCrc();
assert(transbit == 1);
endfunction
 
function void checkCrc();
assert(crc7 == calcCrcOfToken());
endfunction
 
function automatic aCrc7 calcCrcOfToken();
logic temp[$];
 
temp.push_back(startbit);
temp.push_back(transbit);
for (int i = 5; i >= 0; i--)
temp.push_back(id[i]);
for (int i = 31; i >= 0; i--)
temp.push_back(arg[i]);
 
return calcCrc7(temp);
endfunction
 
function automatic bit equals(SDCommandToken rhs);
if(id == rhs.id && arg == rhs.arg) begin
return 1;
end
return 0;
endfunction
 
endclass
 
class SDCommandResponse;
protected logic startbit;
protected logic transbit;
protected logic[5:0] id;
protected SDCommandArg arg;
protected aCrc7 crc;
protected logic endbit;
protected logic data[$];
class SDCommandR7 extends DefaultSdResponse;
 
task sendData(virtual ISdCard.Card ICmd);
foreach(data[i]) begin
@ICmd.cbcard
ICmd.cbcard.Cmd <= data[i];
end
data = {};
@ICmd.cbcard
ICmd.cbcard.Cmd <= 'z;
endtask
 
 
task automatic send(virtual ISdCard.Card ICmd);
aCrc7 crc = 0;
data.push_back(startbit);
data.push_back(transbit);
for(int i = 5; i >= 0; i--)
data.push_back(id[i]);
 
for (int i = 31; i>= 0; i--)
data.push_back(arg[i]);
 
crc = calcCrc7(data);
for (int i = 6; i >= 0; i--)
data.push_back(crc[i]);
 
data.push_back(endbit);
sendData(ICmd);
endtask
endclass
 
class SDCommandR7 extends SDCommandResponse;
 
function new(SDCommandArg arg);
startbit = 0;
transbit = 0;
id = cSdCmdSendIfCond;
this.arg = arg;
endbit = 1;
super.new(cSdCmdSendIfCond, arg);
endfunction
 
endclass
 
class SDCommandR1 extends SDCommandResponse;
class SDCommandR1 extends DefaultSdResponse;
 
function new(int id, SDCardState state);
startbit = 0;
transbit = 0;
this.id = id;
this.arg = state.get();
endbit = 1;
super.new(id, state.get());
endfunction
endclass
 
class SDCommandR3 extends SDCommandResponse;
class SDCommandR3 extends DefaultSdResponse;
 
function new(SDOCR ocr);
startbit = 0;
transbit = 0;
this.id = 'b111111;
this.arg = ocr.get();
endbit = 1;
super.new('b111111, ocr.get());
this.crc = 'b111111;
endfunction
task automatic send(virtual ISdCard.Card ICmd);
data.push_back(startbit);
data.push_back(transbit);
for(int i = 5; i >= 0; i--)
data.push_back(id[i]);
 
for (int i = 31; i>= 0; i--)
data.push_back(arg[i]);
 
for (int i = 6; i >= 0; i--)
data.push_back(1);
 
data.push_back(endbit);
sendData(ICmd);
endtask
 
endclass
 
class SDCommandR2 extends SDCommandResponse;
class SDCommandR2 extends SdBusTrans;
local SDCID cid;
function new();
startbit = 0;
transbit = 0;
this.id = 'b111111;
this.cid = new();
this.cid.randomize();
endbit = 1;
endfunction
 
task automatic send(virtual ISdCard.Card ICmd);
cidreg_t cidreg;
virtual function SdBusTransData packToData();
SdBusTransData data;
SdCommandId id = 'b111111;
cidreg_t creg = cid.get();
 
// fill queue
data.push_back(startbit);
data.push_back(transbit);
for (int i = 5; i >= 0; i--)
data.push_back(id[i]);
data = { >> {cSdTransbitToHost, id, creg}};
return data;
endfunction
 
cidreg = cid.get();
for (int i = 127; i >= 1; i--)
data.push_back(cidreg[i]);
 
data.push_back(endbit);
sendData(ICmd);
endtask
virtual function void unpackFromData(ref SdBusTransData data);
Logger log = new();
log.error("SDCommandR2::unpackFromData not implemented");
endfunction
endclass
 
class SDCommandR6 extends SDCommandResponse;
function SDCommandArg getArgFromRcaAndState(RCA_t rca, SDCardState state);
SDCommandArg arg;
arg[31:16] = rca;
arg[15] = state.ComCrcError;
arg[14] = state.IllegalCommand;
arg[13] = state.Error;
arg[12:9] = state.state;
arg[8] = state.ReadyForData;
arg[7:6] = 0;
arg[5] = state.AppCmd;
arg[4] = 0;
arg[3] = state.AkeSeqError;
arg[2:0] = 0;
return arg;
endfunction
 
class SDCommandR6 extends DefaultSdResponse;
 
function new(RCA_t rca, SDCardState state);
startbit = 0;
transbit = 0;
id = cSdCmdSendRelAdr;
this.arg[31:16] = rca;
this.arg[15] = state.ComCrcError;
this.arg[14] = state.IllegalCommand;
this.arg[13] = state.Error;
this.arg[12:9] = state.state;
this.arg[8] = state.ReadyForData;
this.arg[7:6] = 0;
this.arg[5] = state.AppCmd;
this.arg[4] = 0;
this.arg[3] = state.AkeSeqError;
this.arg[2:0] = 0;
endbit = 1;
super.new(cSdCmdSendRelAdr, getArgFromRcaAndState(rca, state));
endfunction
 
endclass
/sdhc-sc-core/trunk/src/grpSd/unitSdCardModel/src/SDCID.sv
14,7 → 14,7
typedef logic[7:0] prev_t;
typedef logic[31:0] pserialnumber_t;
typedef logic[11:0] manufacturing_date_t;
typedef logic[127:0] cidreg_t;
typedef logic[127:1] cidreg_t; // 1 reserved to endbit
 
class SDCID;
local rand manufacturer_id_t mid;
46,7 → 46,6
temp[23:20] = 0; // reserved
temp[19:8] = date;
temp[7:1] = getCrc(temp); // CRC7
temp[0] = 1;
return temp;
endfunction
 
/sdhc-sc-core/trunk/src/grpSd/unitSdVerificationTestbench/Files.tcl
30,7 → 30,7
set svunits {Sd SdCardModel
Sd SdVerificationTestbench}
 
set sysvlogparams [list +incdir+../../unitSdCardModel/src+../src+../../unitSdWbSlave/src]
set sysvlogparams [list +incdir+../../unitSdCardModel/src+../src+../../unitSdWbSlave/src+../../../grpVerification/unitLogger/src/]
 
#set tb
set top Testbed
/sdhc-sc-core/trunk/src/grpSd/unitSdVerificationTestbench/src/SdVerificationTestbench.sv
31,14 → 31,11
logic[31:0] rd;
Wishbone Bus = new(BusInterface.Master);
SDCard card = new(ICmd, $root.Testbed.CmdReceived, $root.Testbed.InitDone);
SDCommandToken recvCmd, sendCmd;
int c = 0;
 
assert(card.randomize());
ICmd.nResetAsync <= 0;
BusInterface.RST_I <= 1;
#10;
ICmd.nResetAsync <= 1;
BusInterface.RST_I <= 0;
repeat (2) @ICmd.cb;
113,6 → 110,9
endprogram
 
module Testbed();
logic Clk = 0;
logic nResetAsync = 0;
 
ISdCard CardInterface();
WishboneInterface BusInterface();
 
132,15 → 132,19
BusInterface.ACK_I,
BusInterface.ERR_I,
BusInterface.RTY_I,
CardInterface.Clk,
CardInterface.nResetAsync,
Clk,
nResetAsync,
CardInterface.Cmd,
CardInterface.SClk,
CardInterface.Data);
 
always #5 CardInterface.Clk <= ~CardInterface.Clk;
always #5 Clk <= ~Clk;
always #5 BusInterface.CLK_I <= ~BusInterface.CLK_I;
 
initial begin
#10 nResetAsync <= 1;
end
 
Test tb(CardInterface, BusInterface);
 
event ApplyCommand, CardRecv, CmdReceived, GenCmd, InitDone;
/sdhc-sc-core/trunk/src/grpSd/unitSdVerificationTestbench/src/SdCmdInterface.sv
9,30 → 9,17
`define SDCMDINTERFACE
 
interface ISdCard;
logic Clk = 0;
logic nResetAsync;
wire Cmd;
logic SClk;
wire[3:0] Data;
 
clocking cb @(posedge Clk);
clocking cb @(posedge SClk);
inout Cmd;
inout Data;
endclocking
 
modport Testbench (
input Clk, nResetAsync, clocking cb
);
modport card (clocking cb);
 
clocking cbcard @(posedge SClk);
inout Cmd;
inout Data;
endclocking
 
modport Card (
clocking cbcard
);
 
endinterface
 
`endif
/sdhc-sc-core/trunk/src/grpVerification/unitLogger/src/Logger.sv
0,0 → 1,40
//
// file: Logger.sv
// author: Rainer Kastl
//
//
//
 
`ifndef LOGGER_SV
`define LOGGER_SV
 
class Logger;
 
local static int errors = 0;
 
function new();
endfunction
 
function void note(string msg);
$write("Note at %t: ", $time);
$display(msg);
endfunction
 
function void warning(string msg);
$write("Warning at %t: ", $time);
$display(msg);
endfunction
 
function void error(string msg);
$write("Error at %t: ", $time);
$display(msg);
endfunction
 
function void terminate();
$display("Simulation %0sED", (errors) ? "FAIL" : "PASS" );
endfunction
 
endclass
 
`endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.