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
/sdhc-sc-core/trunk/src/grpSd/unitSdCardModel
- from Rev 135 to Rev 145
- ↔ Reverse comparison
Rev 135 → Rev 145
/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 |
/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 |
|
/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; |
/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 |
/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 |
|