Subversion Repositories sdhc-sc-core

//

// file: SdCardModel.sv

// author: Rainer Kastl

//

// Models a SDCard for verification

//

const logic cActivated = 1;

const logic cInactivated = 0;

include "../../unitSdCardModel/src/Crc.sv";

include "../../unitSdCardModel/src/SdCommand.sv";

include "../../unitSdCardModel/src/SdData.sv";

class SDCard;

        local virtual ISdCmd.Card ICmd;

        local SDCardState state;

        local RCA_t rca;

        local SDCommandToken recvcmd;

        local logic CCS;

        local Mode_t mode;

        local DataMode_t datamode;

        local event CmdReceived, InitDone;

        function new(virtual ISdCmd CmdInterface, event CmdReceived, event InitDone);

                ICmd = CmdInterface;

                state = new();

                this.CmdReceived = CmdReceived;

                this.InitDone = InitDone;

                this.CCS = 1;

                rca = 0;

                mode = standard;

                ICmd.cbcard.Data <= 'z;

        endfunction

        task reset();

        endtask

        // Receive a command token and handle it

        task recv();

                ICmd.cbcard.Cmd <= 'z;

                repeat(8) @ICmd.cbcard;

                recvcmd = new();

                wait(ICmd.cbcard.Cmd == 0);

                // Startbit

                recvcmd.startbit = ICmd.cbcard.Cmd;

                @ICmd.cbcard;

                // Transbit

                recvcmd.transbit = ICmd.cbcard.Cmd;

                // CmdID

                for (int i = 5; i >= 0; i--) begin

                        @ICmd.cbcard;

                        recvcmd.id[i] = ICmd.cbcard.Cmd;

                end

                // Arg

                for (int i = 31; i >= 0; i--) begin

                        @ICmd.cbcard;

                        recvcmd.arg[i] = ICmd.cbcard.Cmd;

                end

                // CRC

                for (int i = 6; i >= 0; i--) begin

                        @ICmd.cbcard;

                        recvcmd.crc7[i] = ICmd.cbcard.Cmd;

                end

                // Endbit

                @ICmd.cbcard;

                recvcmd.endbit = ICmd.cbcard.Cmd;

                recvcmd.checkFromHost();

                -> CmdReceived;

        endtask

        task automatic init();

                SDCommandR7 voltageresponse;

                SDCommandR1 response;

                SDCommandR3 acmd41response;

                SDCommandR2 cidresponse;

                SDOCR ocr;

                SDCommandR6 rcaresponse;

                logic data[$];

                SdData sddata;

                // expect CMD0 so that state is clear

                recv();

                assert(recvcmd.id == cSdCmdGoIdleState);

                // expect CMD8: voltage and SD 2.00 compatible

                recv();

                assert(recvcmd.id == cSdCmdSendIfCond);

                assert(recvcmd.arg[12:8] == 'b0001); // Standard voltage

                // respond with R7: we are SD 2.00 compatible and compatible to the

                // voltage

                voltageresponse = new(recvcmd.arg);

                voltageresponse.send(ICmd);

                recvCMD55(0);

                // expect ACMD41 with HCS = 1

                recv();

                assert(recvcmd.id == cSdCmdACMD41);

                assert(recvcmd.arg == cSdArgACMD41HCS);

                // respond with R3

                ocr = new(CCS, cSdVoltageWindow);

                acmd41response = new(ocr);

                acmd41response.send(ICmd);

                recvCMD55(0);

                // expect ACMD41 with HCS = 1

                recv();

                assert(recvcmd.id == cSdCmdACMD41);

                assert(recvcmd.arg == cSdArgACMD41HCS);

                state.AppCmd = 0;

                // respond with R3

                ocr.setBusy(cOCRDone);

                acmd41response = new(ocr);

                acmd41response.send(ICmd);

                // expect CMD2

                recv();

                assert(recvcmd.id == cSdCmdAllSendCID);

                // respond with R2

                cidresponse = new();

                cidresponse.send(ICmd);

                // expect CMD3

                recv();

                assert(recvcmd.id == cSdCmdSendRelAdr);

                // respond with R3

                rcaresponse = new(rca, state);

                rcaresponse.send(ICmd);

                // expect CMD7

                recv();

                assert(recvcmd.id == cSdCmdSelCard);

                assert(recvcmd.arg[31:16] == rca);

                // respond with R1, no busy

                state.ReadyForData = 1;

                response = new(cSdCmdSelCard, state);

                response.send(ICmd);

                // expect ACMD51

                recvCMD55(rca);

                recv();

                assert(recvcmd.id == cSdCmdSendSCR);

                // respond with R1

                response = new(cSdCmdSendSCR, state);

                response.send(ICmd);

                repeat(2) @ICmd.cbcard;

                // send dummy SCR

                for (int i = 0; i < 64; i++)

                        data.push_back(0);

                data[63-50] = 1;

                data[63-48] = 1;

                sddata = new(standard, widewidth);

                sddata.send(ICmd, data);

                // expect ACMD6

                recvCMD55(rca);

                recv();

                assert(recvcmd.id == cSdCmdSetBusWidth);

                assert(recvcmd.arg == 'h00000002);

                response = new(cSdCmdSetBusWidth, state);

                response.send(ICmd);

                sddata.mode = wide;

                // expect CMD6

                recv();

                assert(recvcmd.id == cSdCmdSwitchFuntion);

                assert(recvcmd.arg == 'h00FFFFF1);

                response.send(ICmd);

                // send status data structure

                data = {};

                for (int i = 0; i < 512; i++)

                        data.push_back(0);

                data[511-400] = 1;

                data[511-376] = 1;

                sddata.send(ICmd, data);

                // expect CMD6 with set

                recv();

                assert(recvcmd.id == cSdCmdSwitchFuntion);

                assert(recvcmd.arg == 'h80FFFFF1);

                response.send(ICmd);

                // send status data structure

                data = {};

                for (int i = 0; i < 512; i++)

                        data.push_back(0);

                data[511-400] = 1;

                data[511-376] = 1;

                sddata.send(ICmd, data);

                // switch to 50MHz

                // expect CMD13

                recv();

                assert(recvcmd.id == cSdCmdSendStatus);

                assert(recvcmd.arg == rca);

                response = new(cSdCmdSendStatus, state);

                response.send(ICmd);

                // expect Read

                recv();

                assert(recvcmd.id == cSdCmdReadSingleBlock);

                // recvcmd.arg = address

                response = new(cSdCmdReadSingleBlock, state);

                response.send(ICmd);

                data = {};

                for(int i = 0; i < (512 * 8) - 1; i++)

                        data.push_back(1);

                sddata.send(ICmd, data);

                -> InitDone;

        endtask

        task recvCMD55(RCA_t rca);

                SDCommandR1 response;

                // expect CMD55

                recv();

                assert(recvcmd.id == cSdCmdNextIsACMD);

                assert(recvcmd.arg[31:16] == rca);

                state.recvCMD55();

                // respond with R1

                response = new(cSdCmdNextIsACMD, state);

                response.send(ICmd);

        endtask

        function automatic SDCommandToken getCmd();

                return recvcmd;

        endfunction

        task recvCmd(input SDCommandToken cmd, output SDCommandResponse response);

                case (cmd.id)

                        cSdCmdGoIdleState: reset();

                        default: $display("SDCard: CmdId %d not implemented", cmd.id);

                endcase

        endtask

endclass

class NoSDCard extends SDCard;

        function new(virtual ISdCmd CmdInterface, event CmdReceived, event InitDone);

                super.new(CmdInterface, CmdReceived, InitDone);

        endfunction

        task automatic init();

        endtask

endclass