|
|
@@ -0,0 +1,3067 @@
|
|
|
+MODULE Sd;
|
|
|
+(**
|
|
|
+ AUTHOR Timothée Martiel, 2015
|
|
|
+ PURPOSE SD Card Host Controller Driver
|
|
|
+*)
|
|
|
+
|
|
|
+IMPORT
|
|
|
+ SYSTEM, SdEnvironment, Log := SdEnvironment;
|
|
|
+
|
|
|
+CONST
|
|
|
+ BlockSize * = 512;
|
|
|
+ InitialClockFrequency * = 400000; (* Hz *)
|
|
|
+
|
|
|
+ (* Commands *) (*! Do not change values *)
|
|
|
+ CMD_GO_IDLE_STATE * = 0; (** CMD0 bc [31:0] stuff bits - *)
|
|
|
+ CMD_ALL_SEND_CID * = 2; (** CMD2 bcr [31:0] stuff bits R2 *)
|
|
|
+ CMD_SEND_RELATIVE_ADDR * = 3; (** CMD3 bcr [31:0] stuff bits R6 *)
|
|
|
+ CMD_SET_DSR * = 4; (** CMD4 bc [31:16] DSR [15:0] stuff bits - *)
|
|
|
+ CMD_IO_SEND_OP_COND * = 5; (** CMD5 ?? [31:25] stuff bits [24] switch 1.8V request [23:0] I/O OCR R4 *)
|
|
|
+ CMD_SWITCH_FUNC * = 6; (** CMD6 adtc [31] Mode 0:Check function 1:Switch function [30:24] reserved (All '0') [23:20] reserved for function group 6 (0h or Fh) [19:16] reserved for function group 5 (0h or Fh) [15:12] function group 4 for current limit [11:8] funciton group 3 for drive strength [7:4] function group 2 for command system [3:0] function group 1 for access mode R1 *)
|
|
|
+ CMD_SELECT_DESELECT_CARD * = 7; (** CMD7 ac [31:16] RCA [15:0] stuff bits R1b (only from the selected card) *)
|
|
|
+ CMD_SEND_IF_COND * = 8; (** CMD8 bcr [31:12] reserved bits [11:8] supply voltage(VHS) [7:0]check pattern R7 *)
|
|
|
+ CMD_SEND_CSD * = 9; (** CMD9 ac [31:16] RCA [15:0] stuff bits R2 *)
|
|
|
+ CMD_SEND_CID * = 10; (** CMD10 ac [31:16] RCA [15:0] stuff bits R2 *)
|
|
|
+ CMD_VOLTAGE_SWITCH * = 11; (** CMD11 ac [31:0] reserved bits (all 0) R1 *)
|
|
|
+ CMD_STOP_TRANSMISSION * = 12; (** CMD12 ac [31:0] stuff bits R1b *)
|
|
|
+ CMD_SEND_STATUS * = 13; (** CMD13 ac [31:16] RCA [15:0] stuff bits R1 *)
|
|
|
+ CMD_GO_INACTIVE_STATE * = 15; (** CMD15 ac [31:16] RCA [15:0] reserved bits - *)
|
|
|
+ CMD_SET_BLOCKLEN * = 16; (** CMD16 ac [31:0] block length R1 *)
|
|
|
+ CMD_READ_SINGLE_BLOCK * = 17; (** CMD17 adtc [31:0] data address2 R1 *)
|
|
|
+ CMD_READ_MULTIPLE_BLOCK * = 18; (** CMD18 adtc [31:0] data address2 R1 *)
|
|
|
+ CMD_SEND_TUNING_BLOCK * = 19; (** CMD19 adtc [31:0] reserved bits (all 0) R1 *)
|
|
|
+ CMD_SPEED_CLASS_CONTROL * = 20; (** CMD20 ac [31:28]Speed Class Control [27:0] Reserved (all-0) R1b *)
|
|
|
+ CMD_SET_BLOCK_COUNT * = 23; (** CMD23 ac [31:0] Block Count R1 *)
|
|
|
+ CMD_WRITE_BLOCK * = 24; (** CMD24 adtc [31:0] data address2 R1 *)
|
|
|
+ CMD_WRITE_MULTIPLE_BLOCK * = 25; (** CMD25 adtc [31:0] data address2 R1 *)
|
|
|
+ CMD_PROGRAM_CSD * = 27; (** CMD27 adtc [31:0] stuff bits R1 *)
|
|
|
+ CMD_SET_WRITE_PROT * = 28; (** CMD28 ac [31:0] data address2 R1b *)
|
|
|
+ CMD_CLR_WRITE_PROT * = 29; (** CMD29 ac [31:0] data address2 R1b *)
|
|
|
+ CMD_SEND_WRITE_PROT * = 30; (** CMD30 adtc [31:0] write protect data address2 R1 *)
|
|
|
+ CMD_ERASE_WR_BLK_START * = 32; (** CMD32 ac [31:0] data address1 R1 *)
|
|
|
+ CMD_ERASE_WR_BLK_END * = 33; (** CMD33 ac [31:0] data address1 R1 *)
|
|
|
+ CMD_ERASE * = 38; (** CMD38 ac [31:0] stuff bits R1b *)
|
|
|
+ CMD_LOCK_UNLOCK * = 42; (** CMD42 adtc [31:0] Reserved bits (Set all 0) R1 *)
|
|
|
+ CMD_APP_CMD * = 55; (** CMD55 ac [31:16] RCA [15:0] stuff bits R1 *)
|
|
|
+ CMD_GEN_CMD * = 56; (** CMD56 adtc [31:1] stuff bits. [0] RD/WR R1 *)
|
|
|
+
|
|
|
+ (** Application Commands *) (*! Do Not Change Values *)
|
|
|
+ ACMD_SET_BUS_WIDTH * = 6; (** ACMD6 ac [31:2] stuff bits [1:0] bus width R1 *)
|
|
|
+ ACMD_SD_STATUS * = 13; (** ACMD13 adtc [31:0] stuff bits R1 *)
|
|
|
+ ACMD_SEND_NUM_WR_BLOCKS * = 22; (** ACMD22 adtc [31:0] stuff bits R1 *)
|
|
|
+ ACMD_SET_WR_BLK_ERASE_COUNT * = 23; (** ACMD23 ac [31:23] stuff bits [22:0] Number of blocks R1 *)
|
|
|
+ ACMD_SD_SEND_OP_COND * = 41; (** ACMD41 bcr [31]reserved bit [30] HCS(OCR[30]) [29] reserved for eSD [28] XPC [27:25] reserved bits [24] S18R [23:0] VDD Voltage Window(OCR[23:0]) R3 *)
|
|
|
+ ACMD_SET_CLR_CARD_DETECT * = 42; (** ACMD42 ac [31:1] stuff bits [0] set_cd R1 *)
|
|
|
+ ACMD_SEND_SCR * = 51; (** ACMD51 adtc [31:0] stuff bits R1 *)
|
|
|
+
|
|
|
+ (** Errors *)
|
|
|
+ ErrorNone * = 0; (** No error *)
|
|
|
+ ErrorCmdTimeout * = 1; (** Timeout on command line *)
|
|
|
+ ErrorCmdCrc * = 2; (** CRC error on command line *)
|
|
|
+ ErrorDatTimeout * = 3; (** Timeout on data line *)
|
|
|
+ ErrorDatCrc * = 4; (** CRC error on data line *)
|
|
|
+ ErrorNoCard * = 5; (** No card present *)
|
|
|
+ ErrorCard * = 6; (** Card failed to perform operation *)
|
|
|
+ ErrorUnrecoverable * = 7; (** Host controller in an unrecoverable state *)
|
|
|
+ ErrorInvalidParameters * = 8; (** Invalid parameters *)
|
|
|
+
|
|
|
+ (** Card Versions: maximal SD physical layer specifications version supported by the card *)
|
|
|
+ Version1 * = 0; (** v1.00 or v1.01 *)
|
|
|
+ Version1p1 * = 1; (** v1.10 *)
|
|
|
+ Version2 * = 2; (** v2.00 *)
|
|
|
+ Version3 * = 3; (** v3.01 *)
|
|
|
+ Version4 * = 4; (** v4.10 *)
|
|
|
+ Version5 * = 5; (** v5.10 *)
|
|
|
+ Version6 * =6; (** v6.0 *)
|
|
|
+
|
|
|
+ (** Card Type *)
|
|
|
+ TypeNone * = 0; (** Unknow *)
|
|
|
+ TypeSDSC * = 1; (** SD standard capacity - physical specs v1.0 or v1.1, limited to 2 GB *)
|
|
|
+ TypeSDHC * = 2; (** SD High Capacity - 2 GB to 32 GB *)
|
|
|
+ TypeSDXC * = 3; (** SD Extended Capacity - 32 GB to 2 TB *)
|
|
|
+
|
|
|
+ (** Card Events *)
|
|
|
+ OnInitialization * = 0;
|
|
|
+ OnRemoval * = 1;
|
|
|
+ OnReadComplete * = 2;
|
|
|
+ OnWriteComplete * = 3;
|
|
|
+
|
|
|
+ (** Command Record Flags *)
|
|
|
+ FlagData * = 0;
|
|
|
+ FlagRead * = 1;
|
|
|
+ FlagAutoCmd12 * = 2;
|
|
|
+ FlagAutoCmd23 * = 3;
|
|
|
+ FlagMultipleBlockTx * = 4;
|
|
|
+ FlagCountBlocks * = 5;
|
|
|
+ FlagAbort * = 7;
|
|
|
+ FlagApplicationCmd * = 8;
|
|
|
+ FlagIgnoreIllegalCmd * = 9;
|
|
|
+
|
|
|
+ (** Response Types *) (*! Do not change values *)
|
|
|
+ ResponseNone * = -1;
|
|
|
+ ResponseR1 * = 0;
|
|
|
+ ResponseR1b * = 1;
|
|
|
+ ResponseR2 * = 2;
|
|
|
+ ResponseR3 * = 3;
|
|
|
+ ResponseR4 * = 4;
|
|
|
+ ResponseR5 * = 5;
|
|
|
+ ResponseR5b * = 6;
|
|
|
+ ResponseR6 * = 7;
|
|
|
+ ResponseR7 * = 8;
|
|
|
+
|
|
|
+ (** Host Controller States *)
|
|
|
+ HcOperational * = 0; (** Host controller is operational *)
|
|
|
+ HcConfiguring * = 1; (** Host controller is waiting for configuration input *)
|
|
|
+ HcError * = 2; (** Error occurred *)
|
|
|
+
|
|
|
+ (** Card States *)
|
|
|
+ CardIdle = 0;
|
|
|
+ CardReady = 1;
|
|
|
+ CardIdentification = 2;
|
|
|
+ CardStandby = 3;
|
|
|
+ CardTransfer = 4;
|
|
|
+ CardData = 5;
|
|
|
+ CardReceive = 6;
|
|
|
+ CardProgram = 7;
|
|
|
+ CardDisabled = 8;
|
|
|
+
|
|
|
+ (** Operation modes *)
|
|
|
+ OpCpu = 0;
|
|
|
+ OpSdma = 1;
|
|
|
+ OpAdma = 2;
|
|
|
+
|
|
|
+ (* Present State bits *)
|
|
|
+ PresentState_CommandInhibitCmd = 0;
|
|
|
+ PresentState_CommandInhibitDat = 1;
|
|
|
+ PresentState_DatLineActive = 2;
|
|
|
+ PresentState_RetuningRequest = 3;
|
|
|
+ PresentState_WriteTransferActive = 8;
|
|
|
+ PresentState_ReadTransferActive = 9;
|
|
|
+ PresentState_BufferWriteEnable = 10;
|
|
|
+ PresentState_BufferReadEnable = 11;
|
|
|
+ PresentState_CardInserted = 16;
|
|
|
+ PresentState_CardStateStable = 17;
|
|
|
+ PresentState_CardDetectPinLevel = 18;
|
|
|
+ PresentState_WriteProtectSwitchPinLevel = 19;
|
|
|
+ PresentState_CmdLineSignalLevel = 24;
|
|
|
+ PresentState_DatLineSignalLevelOfs = 20;
|
|
|
+ PresentState_DatLineSignalLevelMask = {20 .. 23};
|
|
|
+
|
|
|
+ (* Interrupt Status, Status Enable, Signal Enable bits *)
|
|
|
+ Interrupt_Normal_CommandComplete = 0;
|
|
|
+ Interrupt_Normal_TransferComplete = 1;
|
|
|
+ Interrupt_Normal_BlockGapEvent = 2;
|
|
|
+ Interrupt_Normal_DmaInterrupt = 3;
|
|
|
+ Interrupt_Normal_BufferWriteReady = 4;
|
|
|
+ Interrupt_Normal_BufferReadReady = 5;
|
|
|
+ Interrupt_Normal_CardInsertion = 6;
|
|
|
+ Interrupt_Normal_CardRemoval = 7;
|
|
|
+ Interrupt_Normal_CardInterrupt = 8;
|
|
|
+ Interrupt_Normal_IntA = 9;
|
|
|
+ Interrupt_Normal_IntB = 10;
|
|
|
+ Interrupt_Normal_IntC = 11;
|
|
|
+ Interrupt_Normal_RetuningEvent = 12;
|
|
|
+ Interrupt_Normal_ErrorInterrupt = 15;
|
|
|
+ Interrupt_Error_CommandTimeout = 16;
|
|
|
+ Interrupt_Error_CommandCrc = 17;
|
|
|
+ Interrupt_Error_CommandEndBit = 18;
|
|
|
+ Interrupt_Error_CommandIndex = 19;
|
|
|
+ Interrupt_Error_DataTimeout = 20;
|
|
|
+ Interrupt_Error_DataCrc = 21;
|
|
|
+ Interrupt_Error_DataEndBit = 22;
|
|
|
+ Interrupt_Error_CurrentLimit = 23;
|
|
|
+ Interrupt_Error_AutoCmd12 = 24;
|
|
|
+ Interrupt_Error_Adma = 25;
|
|
|
+ Interrupt_Error_Tuning = 26;
|
|
|
+ Interrupt_Normal_All = {Interrupt_Normal_CommandComplete, Interrupt_Normal_TransferComplete, Interrupt_Normal_BlockGapEvent, Interrupt_Normal_DmaInterrupt,
|
|
|
+ Interrupt_Normal_BufferWriteReady, Interrupt_Normal_BufferReadReady, Interrupt_Normal_CardInsertion, Interrupt_Normal_CardRemoval,
|
|
|
+ Interrupt_Normal_CardInterrupt, Interrupt_Normal_IntA, Interrupt_Normal_IntB, Interrupt_Normal_IntC, Interrupt_Normal_RetuningEvent,
|
|
|
+ Interrupt_Normal_ErrorInterrupt};
|
|
|
+ Interrupt_Error_All = {Interrupt_Error_CommandTimeout, Interrupt_Error_CommandCrc, Interrupt_Error_CommandEndBit,
|
|
|
+ Interrupt_Error_CommandIndex, Interrupt_Error_DataTimeout, Interrupt_Error_DataCrc, Interrupt_Error_DataEndBit, Interrupt_Error_CurrentLimit,
|
|
|
+ Interrupt_Error_AutoCmd12, Interrupt_Error_Adma, Interrupt_Error_Tuning};
|
|
|
+ Interrupt_All = Interrupt_Normal_All + Interrupt_Error_All;
|
|
|
+
|
|
|
+ (* Transfer Mode Register bits *)
|
|
|
+ TransferMode_DmaEnable = 0;
|
|
|
+ TransferMode_BlockCountEnable = 1;
|
|
|
+ TransferMode_AutoCmdOfs = 2;
|
|
|
+ TransferMode_AutoCmdMask = {2 .. 3};
|
|
|
+ TransferMode_DataTxDirection = 4;
|
|
|
+ TransferMode_MultipleBlocks = 5;
|
|
|
+ TransferMode_AutoCmd_None = {};
|
|
|
+ TransferMode_AutoCmd_Cmd12 = {2};
|
|
|
+ TransferMode_AutoCmd_Cmd23 = {3};
|
|
|
+
|
|
|
+ (* Command Register bits *)
|
|
|
+ Command_ResponseTypeOffset = 0;
|
|
|
+ Command_CrcCheckEnable = 3;
|
|
|
+ Command_IndexCheckEnable = 4;
|
|
|
+ Command_DataPresent = 5;
|
|
|
+ Command_CommandTypeOffset = 6;
|
|
|
+ Command_CommandTypeMask = {6 .. 7};
|
|
|
+ Command_CommandIndexOffset = 8;
|
|
|
+ Command_CommandIndexMask = {8 .. 13};
|
|
|
+
|
|
|
+ Command_ResponseType_None = 0;
|
|
|
+ Command_ResponseType_136b = 1;
|
|
|
+ Command_ResponseType_48b = 2;
|
|
|
+ Command_ResponseType_48bBusy = 3;
|
|
|
+
|
|
|
+ (* Capabilities Register *)
|
|
|
+ (* Low Word *)
|
|
|
+ Capabilities_TimeoutClockFrequencyOfs = 0;
|
|
|
+ Capabilities_TimeoutClockFrequencyMask = {0 .. 5};
|
|
|
+ Capabilities_TimeoutClockUnit = 7;
|
|
|
+ Capabilities_BaseClockFreqSdOfs = 8;
|
|
|
+ Capabilities_BaseClockFreqSdMask = {8 .. 15};
|
|
|
+ Capabilities_MaxBlockLenOfs = 16;
|
|
|
+ Capabilities_MaxBlockLenMask = {16 .. 17};
|
|
|
+ Capabilities_8BitEmbedded = 18;
|
|
|
+ Capabilities_ADMA2 = 19;
|
|
|
+ Capabilities_HighSpeed = 21;
|
|
|
+ Capabilities_SDMA = 22;
|
|
|
+ Capabilities_SuspendResume = 23;
|
|
|
+ Capabilities_Voltage33 = 24;
|
|
|
+ Capabilities_Voltage30 = 25;
|
|
|
+ Capabilities_Voltage18 = 26;
|
|
|
+ Capabilities_64BitBus = 28;
|
|
|
+ Capabilities_AsyncInterrupt = 29;
|
|
|
+ Capabilities_SlotTypeOfs = 30;
|
|
|
+ Capabilities_SlotTypeMask = {30 .. 31};
|
|
|
+ (* High Word *)
|
|
|
+ Capabilities_SDR50 = 0;
|
|
|
+ Capabilities_SDR104 = 1;
|
|
|
+ Capabilities_DDR50 = 2;
|
|
|
+ Capabilities_DriverTypeA = 4;
|
|
|
+ Capabilities_DriverTypeC = 5;
|
|
|
+ Capabilities_DriverTypeD = 6;
|
|
|
+ Capabilities_TimerCountRetuningOfs = 8;
|
|
|
+ Capabilities_TimerCountRetuningMask = {8 .. 11};
|
|
|
+ Capabilities_TuningSDR50 = 13;
|
|
|
+ Capabilities_RetuningModesOfs = 14;
|
|
|
+ Capabilities_RetuningModesMask = {14 .. 15};
|
|
|
+ Capabilities_ClockMultiplierOfs = 16;
|
|
|
+ Capabilities_ClockMultiplierMask = {16 .. 23};
|
|
|
+ (* Patterns *)
|
|
|
+ Capabilities_SlotType_Removable = {};
|
|
|
+ Capabilities_SlotType_Embedded = {30};
|
|
|
+ Capabilities_SlotType_SharedBus = {31};
|
|
|
+
|
|
|
+ (* Host Control 1 register values *)
|
|
|
+ HostControl1_LedControl = 0;
|
|
|
+ HostControl1_DataTransferWidth = 1;
|
|
|
+ HostControl1_HighSpeedEnable = 2;
|
|
|
+ HostControl1_DmaSelectOfs = 3;
|
|
|
+ HostControl1_DmaSelectMask = {3 .. 4};
|
|
|
+ HostControl1_ExtendedDataTxWidth = 5;
|
|
|
+ HostControl1_CardDetectTestLevel = 6;
|
|
|
+ HostControl1_CardDetectSignalSelection = 7;
|
|
|
+ HostControl1_DmaSelect_Sdma = {};
|
|
|
+ HostControl1_DmaSelect_32Adma = {4};
|
|
|
+
|
|
|
+ (* SoftwareReset register values *)
|
|
|
+ SoftwareResetAll = 1;
|
|
|
+ SoftwareResetCmd = 2;
|
|
|
+ SoftwareResetDat = 4;
|
|
|
+
|
|
|
+ (* Clock Control register values *)
|
|
|
+ ClockControl_InternalClockEnable = 0;
|
|
|
+ ClockControl_InternalClockState = 1;
|
|
|
+ ClockControl_SdClockEnable = 2;
|
|
|
+ ClockControl_ClockGeneratorSelect = 5;
|
|
|
+ ClockControl_SdClockFreqUpperOfs = 6;
|
|
|
+ ClockControl_SdClockFreqUpperMask = {6, 7};
|
|
|
+ ClockControl_SdClockFreqOfs = 8;
|
|
|
+ ClockControl_SdClockFreqMask = {8 .. 15};
|
|
|
+
|
|
|
+ (* Power Control register values *)
|
|
|
+ PowerControl_SDBusPower* = 0;
|
|
|
+ PowerControl_SDBusVoltageOfs = 1;
|
|
|
+ PowerControl_SDBusVoltageMask = {1 .. 3};
|
|
|
+ PowerControl_SDBusVoltage_18 = {1, 3};
|
|
|
+ PowerControl_SDBusVoltage_30 = {2, 3};
|
|
|
+ PowerControl_SDBusVoltage_33 = {1, 2, 3};
|
|
|
+
|
|
|
+ (* Host Controller Version *)
|
|
|
+ HostControllerVersion_SpecificationMask = {0 .. 7};
|
|
|
+ HostControllerVersion_VendorOfs = 8;
|
|
|
+ HostControllerVersion_VendorMask = {8 .. 15};
|
|
|
+
|
|
|
+
|
|
|
+ (* SD Status fields *)
|
|
|
+ SdStatus_FuleSupport = 312;
|
|
|
+ SdStatus_DiscardSupport = 313;
|
|
|
+ SdStatus_PerformanceEnhanceOfs = 335;
|
|
|
+ SdStatus_PerformanceEnhanceWidth = 8;
|
|
|
+ SdStatus_AppPerfClassOfs = 336;
|
|
|
+ SdStatus_AppPerfClassWidth = 4;
|
|
|
+ SdStatus_SusAddrOfs = 346;
|
|
|
+ SdStatus_SusAddrWidth = 22;
|
|
|
+ SdStatus_VscAuSizeOfs = 368;
|
|
|
+ SdStatus_VscAuSizeWidth = 10;
|
|
|
+ SdStatus_VideoSpeedClassOfs = 384;
|
|
|
+ SdStatus_VideoSpeedClassWidth = 8;
|
|
|
+ SdStatus_UhsAuSizeOfs = 392;
|
|
|
+ SdStatus_UhsAuSizeWidth = 4;
|
|
|
+ SdStatus_UhsSpeedGradeOfs = 396;
|
|
|
+ SdStatus_UhsSpeedGradeWidth = 4;
|
|
|
+ SdStatus_EraseOffsetOfs = 400;
|
|
|
+ SdStatus_EraseOffsetWidth = 2;
|
|
|
+ SdStatus_EraseTimeoutOfs = 402;
|
|
|
+ SdStatus_EraseTimeoutWidth = 6;
|
|
|
+ SdStatus_EraseSizeOfs = 408;
|
|
|
+ SdStatus_EraseSizeWidth = 16;
|
|
|
+ SdStatus_AuSizeOfs = 428;
|
|
|
+ SdStatus_AuSizeWidth = 4;
|
|
|
+ SdStatus_PerformanceMoveOfs = 432;
|
|
|
+ SdStatus_PerformanceMoveWidth = 8;
|
|
|
+ SdStatus_SpeedClassOfs = 440;
|
|
|
+ SdStatus_SpeedClassWidth = 8;
|
|
|
+ SdStatus_SizeOfProtectedAreaOfs = 448;
|
|
|
+ SdStatus_SizeOfProtectedAreaWidth = 32;
|
|
|
+ SdStatus_SdCardTypeOfs = 480;
|
|
|
+ SdStatus_SdCardTypeWidth = 16;
|
|
|
+ SdStatus_SecuredMode = 509;
|
|
|
+ SdStatus_DatBusWidthOfs = 510;
|
|
|
+ SdStatus_DatBusWidthWidth = 2;
|
|
|
+
|
|
|
+ (* Card Status register -- R1 *)
|
|
|
+ CardStatus_AkeSpecError = 3;
|
|
|
+ CardStatus_AppCmd = 5;
|
|
|
+ CardStatus_ReadyForData = 8;
|
|
|
+ CardStatus_CurrentStateOffset = 9;
|
|
|
+ CardStatus_CurrentStateMask = {9 .. 12};
|
|
|
+ CardStatus_EraseReset = 13;
|
|
|
+ CardStatus_CardEccDisable = 14;
|
|
|
+ CardStatus_WpEraseSkip = 15;
|
|
|
+ CardStatus_CsdOverwrite = 16;
|
|
|
+ CardStatus_Error = 19;
|
|
|
+ CardStatus_CcError = 20;
|
|
|
+ CardStatus_CardEccFailed = 21;
|
|
|
+ CardStatus_IllegalCommand = 22;
|
|
|
+ CardStatus_ComCrcError = 23;
|
|
|
+ CardStatus_LockUnlockFailed = 24;
|
|
|
+ CardStatus_CardIsLocked = 25;
|
|
|
+ CardStatus_WpViolation = 26;
|
|
|
+ CardStatus_EraseParam = 27;
|
|
|
+ CardStatus_EraseSeqError = 28;
|
|
|
+ CardStatus_BlockLenError = 29;
|
|
|
+ CardStatus_AddressError = 30;
|
|
|
+ CardStatus_OutOfRange = 31;
|
|
|
+
|
|
|
+ (* OCR Registers *)
|
|
|
+ CardOcr_Vdd27_28 = 15;
|
|
|
+ CardOcr_Vdd28_29 = 16;
|
|
|
+ CardOcr_Vdd29_30 = 17;
|
|
|
+ CardOcr_Vdd30_31 = 18;
|
|
|
+ CardOcr_Vdd31_32 = 19;
|
|
|
+ CardOcr_Vdd32_33 = 20;
|
|
|
+ CardOcr_Vdd33_34 = 21;
|
|
|
+ CardOcr_Vdd34_35 = 22;
|
|
|
+ CardOcr_Vdd35_36 = 23;
|
|
|
+ CardOcr_S18A = 24;
|
|
|
+ CardOcr_UHS2CardStatus = 29;
|
|
|
+ CardOcr_CardCapacityStatus = 30;
|
|
|
+ CardOcr_PowerUpStatus = 31;
|
|
|
+
|
|
|
+ (* CID Register *)
|
|
|
+ CardCid_ManufacturerIdOfs = 112;
|
|
|
+ CardCid_ManufacturerIdWidth = 8;
|
|
|
+ CardCid_OEM_ApplicationIdOfs = 96;
|
|
|
+ CardCid_OEM_ApplicationIdWidth = 16;
|
|
|
+ CardCid_ProductNameOfs = 56;
|
|
|
+ CardCid_ProductNameWidth = 40;
|
|
|
+ CardCid_ProductRevisionOfs = 48;
|
|
|
+ CardCid_ProductRevisionWidth = 8;
|
|
|
+ CardCid_ProductSerialNbOfs = 16;
|
|
|
+ CardCid_ProductSerialNbWidth = 32;
|
|
|
+ CardCid_ProductManufacturingDateOfs = 0;
|
|
|
+ CardCid_ProductManufacturingDateWidth = 12;
|
|
|
+
|
|
|
+ (* CSD Register. This excludes the CRC7 of the specifications. *)
|
|
|
+ CardCsd_FileFormatOfs = 2;
|
|
|
+ CardCsd_FileFormatWidth = 2;
|
|
|
+ CardCsd_TmpWriteProtect = 4;
|
|
|
+ CardCsd_PermWriteProtect = 5;
|
|
|
+ CardCsd_Copy = 6;
|
|
|
+ CardCsd_FileFormatGrp = 7;
|
|
|
+ CardCsd_WriteBlPartial = 13;
|
|
|
+ CardCsd_WriteBlLenOfs = 14;
|
|
|
+ CardCsd_WriteBlLenWidth = 4;
|
|
|
+ CardCsd_R2wFactorOfs = 18;
|
|
|
+ CardCsd_R2wFactorWidth = 3;
|
|
|
+ CardCsd_WpGrpEnable = 23;
|
|
|
+ CardCsd_WpGrpSizeOfs = 24;
|
|
|
+ CardCsd_WpGrpSizeWidth = 7;
|
|
|
+ CardCsd_SectorSizeOfs = 31;
|
|
|
+ CardCsd_SectorSizeWidth = 7;
|
|
|
+ CardCsd_EraseBlkEn = 38;
|
|
|
+ CardCsd_CSizeMultOfs1 = 39; (** V1 *)
|
|
|
+ CardCsd_CSizeMultWidth1 = 3; (** V1 *)
|
|
|
+ CardCsd_VddWCurrMaxOfs1 = 42; (** V1 *)
|
|
|
+ CardCsd_VddWCurrMaxWidth1 = 3; (** V1 *)
|
|
|
+ CardCsd_VddWCurrMinOfs1 = 45; (** V1 *)
|
|
|
+ CardCsd_VddWCurrMinWidth1 = 3; (** V1 *)
|
|
|
+ CardCsd_VddRCurrMaxOfs1 = 48; (** V1 *)
|
|
|
+ CardCsd_VddRCurrMaxWidth1 = 3; (** V1 *)
|
|
|
+ CardCsd_VddRCurrMinOfs1 = 51; (** V1 *)
|
|
|
+ CardCsd_VdddRCurrMaxWidth1 = 3; (** V1 *)
|
|
|
+ CardCsd_CSizeOfs1 = 54; (** V1 *)
|
|
|
+ CardCsd_CSizeWidth1 = 12; (** V1 *)
|
|
|
+ CardCsd_CSizeOfs2 = 40; (** V2 *)
|
|
|
+ CardCsd_CSizeWidth2 = 22; (** V2 *)
|
|
|
+ CardCsd_DsrImp = 68;
|
|
|
+ CardCsd_ReadBlkMisalign = 69;
|
|
|
+ CardCsd_WriteBlkMisalign = 70;
|
|
|
+ CardCsd_ReadBlPartial = 71;
|
|
|
+ CardCsd_ReadBlLenOfs = 72;
|
|
|
+ CardCsd_ReadBlLenWidth = 4;
|
|
|
+ CardCsd_CccOfs = 76;
|
|
|
+ CardCsd_CccWidth = 12;
|
|
|
+ CardCsd_TranSpeedOfs = 88;
|
|
|
+ CardCsd_TranSpeedWidth = 8;
|
|
|
+ CardCsd_NsacOfs = 96;
|
|
|
+ CardCsd_NsacWidth = 8;
|
|
|
+ CardCsd_TaacOfs = 104;
|
|
|
+ CardCsd_TaacWidth = 8;
|
|
|
+ CardCsd_CsdStructureOfs = 118;
|
|
|
+ CardCsd_CsdStructureWidth = 2;
|
|
|
+
|
|
|
+ (* SCR Register *)
|
|
|
+ CardScr_CommandSupportOfs = 32;
|
|
|
+ CardScr_CommandSupportWidth = 4;
|
|
|
+ CardScr_SpecVXOfs = 38;
|
|
|
+ CardScr_SpecVXWidth = 4;
|
|
|
+ CardScr_SpecV4 = 42;
|
|
|
+ CardScr_ExtendedSecurityOfs = 43;
|
|
|
+ CardScr_ExtendedSecurityWidth = 4;
|
|
|
+ CardScr_SpecV3 = 47;
|
|
|
+ CardScr_BusWidthsOfs = 48;
|
|
|
+ CardScr_BusWidthsWidth = 4;
|
|
|
+ CardScr_SecurityOfs = 52;
|
|
|
+ CardScr_SecurityWidth = 3;
|
|
|
+ CardScr_DataStateAfterErase = 55;
|
|
|
+ CardScr_SpecVersionOfs = 56;
|
|
|
+ CardScr_SpecVersionWidth = 4;
|
|
|
+ CardScr_StructureOfs = 60;
|
|
|
+ CardScr_StructureWidth = 4;
|
|
|
+
|
|
|
+ (* SCR register fields values *)
|
|
|
+ CardScr_SpecVX_v5 = 1;
|
|
|
+ CardScr_SpecVX_v6 = 2;
|
|
|
+
|
|
|
+ (* Card categories, used in SD status card type *)
|
|
|
+ CategoryRW * = 0;
|
|
|
+ CategoryRO * = 1;
|
|
|
+ CategoryOTP * = 2;
|
|
|
+
|
|
|
+ (* Performance enhancing features, used in perfEnhance in SD status *)
|
|
|
+ PerformanceCardMaintenance * = 0; (** Card supports card-initiated maintenance *)
|
|
|
+ PerformanceHostMaintenance * = 1; (** Card supports host-initiated maintenance *)
|
|
|
+ PerformanceCache * = 2; (** Card supports internal caching *)
|
|
|
+ PerformanceQueue * =3; (** Card supports command queue *)
|
|
|
+
|
|
|
+ (* Transfer options *)
|
|
|
+ TxDma = TRUE; (** Use DMA for transfers on all hosts that support it *)
|
|
|
+ TxBufferSize = 4096; (** Buffer size used for DMA transfers *)
|
|
|
+ TxBufferAlign = 32; (** Alignment requirement on DMA buffer: here cache line size of ARM *)
|
|
|
+
|
|
|
+ (* ADMA2 flags *) (*! Do not change values *)
|
|
|
+ Adma2Valid = 0; (** Valid entry *)
|
|
|
+ Adma2End = 1; (** Last entry *)
|
|
|
+ Adma2Int = 2; (** Entry generates interrupt on completion *)
|
|
|
+ Adma2Nop = {}; (** No-operation, just continue to next *)
|
|
|
+ Adma2Trans = {5}; (** Transfer descriptor *)
|
|
|
+ Adma2Link = {4, 5}; (** Link descriptor *)
|
|
|
+ Adma2ActMask = {4, 5}; (** Mask for Nop, Trans and Link *)
|
|
|
+
|
|
|
+ (* Timeout values *)
|
|
|
+ TimeoutCardInit = 100; (** Timeout used in card initialization, ms *)
|
|
|
+ TimeoutReadFactor = 100; (** Timeout factor on typical read time (according to CSD) *)
|
|
|
+ TimeoutReadFix = 100; (** Maximal read timeout in ms. To be used unconditionally with SDHC *)
|
|
|
+ TimeoutWriteFactor = 100; (** Timeout factor on typical write time (according to CSD) *)
|
|
|
+ TimeoutWriteFix = 250; (** Maximal write timeout in ms. To be used unconditionally with SDHC *)
|
|
|
+ TimeoutErase = 250; (** Typical timeout per erased block, ms *)
|
|
|
+
|
|
|
+ DefaultTimeout = 1000; (* Default timeout for blocking, in ms *)
|
|
|
+
|
|
|
+ (* Multi-threading *)
|
|
|
+ Synchronize * = FALSE (*TRUE*); (** Do we need to take care of concurrency? *)
|
|
|
+
|
|
|
+ (* Tracing options for debugging *)
|
|
|
+ EnableTraceCmd* = FALSE;
|
|
|
+ EnableTrace* = FALSE;
|
|
|
+
|
|
|
+TYPE
|
|
|
+ (** Command execution procedure *)
|
|
|
+ CommandProcedure * = PROCEDURE (VAR command: Command; VAR result: LONGINT): BOOLEAN;
|
|
|
+ (** Data command execution procedure *)
|
|
|
+ TransferProcedure * = PROCEDURE (VAR command: Command; VAR data: ARRAY OF SYSTEM.BYTE; ofs, len: LONGINT; VAR result: LONGINT): BOOLEAN;
|
|
|
+ (** Procedure called to wait for interrupt. mask specifies which interrupts are expected, timeout is in ms. Returns FALSE if timeout occurred *)
|
|
|
+ Blocker * = PROCEDURE {DELEGATE} (hc: HostController; mask: SET; timeout: LONGINT): BOOLEAN;
|
|
|
+
|
|
|
+ (**
|
|
|
+ SD Host controller descriptor.
|
|
|
+ *)
|
|
|
+ HostController * = POINTER TO HostControllerDesc;
|
|
|
+ HostControllerDesc * = RECORD
|
|
|
+ state -, (** HC state *)
|
|
|
+ version -: LONGINT; (** Specifications version *)
|
|
|
+
|
|
|
+ execute -: CommandProcedure; (** Method to execute commands *)
|
|
|
+ transfer -: TransferProcedure; (** Method to execute data commands *)
|
|
|
+ acquire *, release *: PROCEDURE {DELEGATE}; (** Procedures used for locking *)
|
|
|
+
|
|
|
+ baseFrequency, (** Base hc clock frequency *)
|
|
|
+ frequency, (** Bus frequency *)
|
|
|
+ timeoutFrequency: HUGEINT; (** Timeout clock frequency *)
|
|
|
+ lastRca: LONGINT; (** Last RCA selected by the controller. *)
|
|
|
+
|
|
|
+ handle: EventHandler; (** Card event handler *)
|
|
|
+ handlerParam: ANY; (** Parameter of the eventHandler *)
|
|
|
+ block: Blocker; (** Procedure called to wait for interrupts *)
|
|
|
+
|
|
|
+ regs-: HcRegisters; (** Memory-mapped I/O registers *)
|
|
|
+ cards: Card; (** List of cards on this HC *)
|
|
|
+ next: HostController; (** Linked list of controllers for interrupt handling *)
|
|
|
+ desc{ALIGNED(32)}: ARRAY 32 OF HUGEINT; (** DMA descriptor *)
|
|
|
+ END;
|
|
|
+
|
|
|
+ (**
|
|
|
+ Command record.
|
|
|
+ This record type is used to describe a command and its result.
|
|
|
+ To execute a command, fill in the fields 'hc', 'command', 'argument', 'responseType'.
|
|
|
+ If the command uses the DAT line or is an application command, setup then necessary flags.
|
|
|
+ If the command is an application command, you also need to specify the RCA for CMD55.
|
|
|
+ After command execution, you can read the command response in the 'response' field. Use the
|
|
|
+ 'GetR*' procedures to extract all information from this field in a convenient way.
|
|
|
+ *)
|
|
|
+ Command * = RECORD
|
|
|
+ hc *: HostController; (** Host controller on which the command is executed *)
|
|
|
+ rca *, (** Optional RCA parameter. Required only for ACMDs *)
|
|
|
+ command *, (** Command number *)
|
|
|
+ argument *, (** Command argument *)
|
|
|
+ responseType *, (** Response type *)
|
|
|
+ blockSize *, (** Block size for read, write or erase *)
|
|
|
+ dataTimeout *: LONGINT; (** Timeout value used for data line *)
|
|
|
+ flags *: SET; (** Command flags *)
|
|
|
+ response *: ARRAY 4 OF LONGINT; (** Response *)
|
|
|
+ END;
|
|
|
+
|
|
|
+ (** SWITCH_FUNC returned status *)
|
|
|
+ SwitchFuncStatus * = RECORD
|
|
|
+ current -: LONGINT; (** Current for specified config *)
|
|
|
+ functionGroups -: ARRAY 6 OF SET; (** Supported function in each group *)
|
|
|
+ functionStatus -: ARRAY 6 OF LONGINT; (** Function status *)
|
|
|
+ END;
|
|
|
+
|
|
|
+ (** Card event handler. 'card' is the card for which an event is reported (can be a new card object) and 'event' is one of 'On*' constants *)
|
|
|
+ EventHandler * = PROCEDURE {DELEGATE} (card: Card; event: LONGINT; param: ANY);
|
|
|
+
|
|
|
+ (** Host controller registers *)
|
|
|
+ HcRegisters * = POINTER {UNSAFE,UNTRACED} TO RECORD
|
|
|
+ SDMASystemAddress * {ALIGNED(1)}: LONGINT; (** offset = 0H *)
|
|
|
+ BlockSize * {ALIGNED(1)}, (** offset = 4H *)
|
|
|
+ BlockCount * {ALIGNED(1)}: INTEGER; (** offset = 6H *)
|
|
|
+ Argument1 * {ALIGNED(1)}: LONGINT; (** offset = 8H *)
|
|
|
+ TransferMode * {ALIGNED(1)}, (** offset = 0CH *)
|
|
|
+ Command * {ALIGNED(1)}: INTEGER; (** offset = 0EH *)
|
|
|
+ Response * {ALIGNED(1)}: ARRAY 4 OF LONGINT; (** offset = 10H *)
|
|
|
+ BufferData * {ALIGNED(1)}: LONGINT;
|
|
|
+ PresentState * {ALIGNED(1)}: SET;
|
|
|
+ HostControl1 * {ALIGNED(1)},
|
|
|
+ PowerControl * {ALIGNED(1)},
|
|
|
+ BlockGapControl * {ALIGNED(1)},
|
|
|
+ WakeupControl * {ALIGNED(1)}: SHORTINT;
|
|
|
+ ClockControl * {ALIGNED(1)}: INTEGER;
|
|
|
+ TimeoutControl * {ALIGNED(1)},
|
|
|
+ SoftwareReset * {ALIGNED(1)}: SHORTINT;
|
|
|
+ InterruptStatus * {ALIGNED(1)},
|
|
|
+ InterruptStatusEnable * {ALIGNED(1)},
|
|
|
+ InterruptSignalEnable * {ALIGNED(1)}: SET;
|
|
|
+ AutoCmdErrorStatus * {ALIGNED(1)},
|
|
|
+ HostControl2 * {ALIGNED(1)}: INTEGER;
|
|
|
+ Capabilities * {ALIGNED(1)}: ARRAY 2 OF SET;
|
|
|
+ MaximumCurrentCapabilities * {ALIGNED(1)}: HUGEINT;
|
|
|
+ ForceEventAutoCmdErrorStatus * {ALIGNED(1)},
|
|
|
+ ForceEventErrorInterruptStatus * {ALIGNED(1)}: INTEGER;
|
|
|
+ AdmaErrorStatus * {ALIGNED(1)}: SHORTINT;
|
|
|
+ padding0 * {ALIGNED(1)}: ARRAY 3 OF SHORTINT;
|
|
|
+ AdmaSystemAddress * {ALIGNED(1)}: HUGEINT;
|
|
|
+ PresetValues * {ALIGNED(1)}: ARRAY 8 OF INTEGER;
|
|
|
+ padding1 * {ALIGNED(1)}: ARRAY 28 OF LONGINT;
|
|
|
+ SharedBusControl * {ALIGNED(1)}: LONGINT;
|
|
|
+ padding2 * {ALIGNED(1)}: ARRAY 6 OF LONGINT;
|
|
|
+ SlotInterruptStatus * {ALIGNED(1)},
|
|
|
+ HostControllerVersion * {ALIGNED(1)}: INTEGER;
|
|
|
+ END;
|
|
|
+
|
|
|
+VAR
|
|
|
+ (** List of all host controllers *)
|
|
|
+ hcs: HostController;
|
|
|
+
|
|
|
+ (** Statistics *)
|
|
|
+ NbyteRead -,
|
|
|
+ NbyteWritten -,
|
|
|
+ Nread -,
|
|
|
+ Nwrite -: HUGEINT;
|
|
|
+ Tread -,
|
|
|
+ Twrite -: HUGEINT;
|
|
|
+ start, stop: HUGEINT;
|
|
|
+
|
|
|
+ (* ==================== Host Controller (Low-Level) Interface ==================== *)
|
|
|
+ (**
|
|
|
+ Create an host controller descriptor and initializes it with the given info.
|
|
|
+ 'baseAddress' is the base address of the IO registers.
|
|
|
+ 'extClockFreq' is an optional external clock frequency. It is used iff the host controller has no information about its clock frequency.
|
|
|
+ 'handler' is the event handler and 'param' is user parameter.
|
|
|
+ *)
|
|
|
+ PROCEDURE InitHostController * (hc: HostController; baseAddress: ADDRESS)(*: HostController*);
|
|
|
+ VAR
|
|
|
+ val: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ hc.regs := baseAddress;
|
|
|
+ IF ~Reset(hc, TRUE, TRUE) THEN (*RETURN NIL*) END;
|
|
|
+ hc.baseFrequency := LSH(SYSTEM.VAL(LONGINT, hc.regs.Capabilities[0] * Capabilities_BaseClockFreqSdMask), -Capabilities_BaseClockFreqSdOfs);
|
|
|
+ hc.timeoutFrequency := LSH(SYSTEM.VAL(LONGINT, hc.regs.Capabilities[0] * Capabilities_TimeoutClockFrequencyMask), -Capabilities_TimeoutClockFrequencyOfs) * 1000;
|
|
|
+ IF Capabilities_TimeoutClockUnit IN hc.regs.Capabilities[0] THEN hc.timeoutFrequency := hc.timeoutFrequency * 1000 END;
|
|
|
+ (*SetBusClock(hc, InitialClockFrequency);
|
|
|
+ SetTimeout(hc, 100);*)
|
|
|
+
|
|
|
+ (* Power select 3.3V bus voltage *)
|
|
|
+ hc.regs.PowerControl := SYSTEM.VAL(SHORTINT, PowerControl_SDBusVoltage_33 + {PowerControl_SDBusPower});
|
|
|
+
|
|
|
+ (* Enable All Interrupts *)
|
|
|
+ hc.regs.InterruptStatusEnable := Interrupt_All;
|
|
|
+ hc.regs.InterruptSignalEnable := {Interrupt_Normal_CardInsertion, Interrupt_Normal_CardRemoval};
|
|
|
+ hc.regs.BlockGapControl := 0;
|
|
|
+
|
|
|
+ val := LONGINT(hc.regs.HostControllerVersion);
|
|
|
+ hc.version := SYSTEM.VAL(LONGINT, SYSTEM.VAL(SET, val) * HostControllerVersion_SpecificationMask) + 1;
|
|
|
+
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] New Host Controller v");
|
|
|
+ Log.Int(hc.version, 0);
|
|
|
+ Log.String(" at ");
|
|
|
+ Log.Address(baseAddress);
|
|
|
+ Log.Ln;
|
|
|
+ PrintCapabilities(hc);
|
|
|
+ END;
|
|
|
+
|
|
|
+ IF Synchronize THEN SdEnvironment.GetLock(hc.acquire, hc.release) END;
|
|
|
+
|
|
|
+ (* Select method according to DMA support *)
|
|
|
+ IF TxDma THEN
|
|
|
+ IF (Capabilities_ADMA2 IN hc.regs.Capabilities[0]) THEN
|
|
|
+ hc.transfer := ExecuteAdmaCommand;
|
|
|
+ hc.regs.HostControl1 := SYSTEM.VAL(SHORTINT, SYSTEM.VAL(SET, LONGINT(hc.regs.HostControl1)) + HostControl1_DmaSelect_32Adma);
|
|
|
+ ELSE
|
|
|
+ (*! ADMA1 and SDMA are not implemented yet *)
|
|
|
+ hc.transfer := ExecuteDataCommand
|
|
|
+ END
|
|
|
+ ELSE
|
|
|
+ hc.transfer := ExecuteDataCommand
|
|
|
+ END;
|
|
|
+ hc.execute := ExecuteCommand;
|
|
|
+ hc.block := SpinBlock; (* Use spin block by default *)
|
|
|
+
|
|
|
+ IF (hc.baseFrequency = 0) OR (hc.timeoutFrequency = 0) THEN
|
|
|
+ hc.state := HcConfiguring
|
|
|
+ ELSE
|
|
|
+ hc.state := HcOperational
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* If there is a card already, initialize it *)
|
|
|
+ (*IF (PresentState_CardInserted IN hc.regs.PresentState) & (PresentState_CardStateStable IN hc.regs.PresentState) THEN
|
|
|
+ NEW(hc.cards);
|
|
|
+ IF InitCard(hc, hc.cards, result) & (hc.handle # NIL) THEN
|
|
|
+ hc.handle(hc.cards, OnInitialization, hc.handlerParam)
|
|
|
+ ELSIF hc.handle # NIL THEN
|
|
|
+ Log.String("[SD] Could not initialize inserted card: error ");
|
|
|
+ Log.Int(result, 0);
|
|
|
+ Log.Ln;
|
|
|
+ END
|
|
|
+ END;*)
|
|
|
+
|
|
|
+ hc.next := hcs;
|
|
|
+ hcs := hc;
|
|
|
+ END InitHostController;
|
|
|
+
|
|
|
+ (** Set external clock for a host controller. Host state must be HcConfiguring. bus is the SD bus clock frequency, timeout is the timeout clock frequency. *)
|
|
|
+ PROCEDURE SetExternalClock * (hc: HostController; bus, timeout: HUGEINT; VAR result: LONGINT): BOOLEAN;
|
|
|
+ BEGIN
|
|
|
+ IF hc.state # HcConfiguring THEN
|
|
|
+ result := ErrorInvalidParameters;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ hc.baseFrequency := bus;
|
|
|
+ hc.timeoutFrequency := timeout;
|
|
|
+ hc.state := HcOperational;
|
|
|
+ RETURN TRUE
|
|
|
+ END SetExternalClock;
|
|
|
+
|
|
|
+ (** Set an event handler for a host controller *)
|
|
|
+ PROCEDURE SetEventHandler * (hc: HostController; handler: EventHandler; param: ANY);
|
|
|
+ VAR
|
|
|
+ result: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ hc.handle := handler;
|
|
|
+ hc.handlerParam := param;
|
|
|
+
|
|
|
+ (* Handle events if necessary *)
|
|
|
+ IF (PresentState_CardInserted IN hc.regs.PresentState) & (PresentState_CardStateStable IN hc.regs.PresentState) THEN
|
|
|
+ NEW(hc.cards);
|
|
|
+ IF InitCard(hc, hc.cards, result) & (hc.handle # NIL) THEN
|
|
|
+ hc.handle(hc.cards, OnInitialization, hc.handlerParam)
|
|
|
+ ELSIF hc.handle # NIL THEN
|
|
|
+ Log.String("[SD] Could not initialize inserted card: error ");
|
|
|
+ Log.Int(result, 0);
|
|
|
+ Log.Ln;
|
|
|
+ END
|
|
|
+ END;
|
|
|
+ END SetEventHandler;
|
|
|
+
|
|
|
+ (** Change the wait for interrupt method *)
|
|
|
+ PROCEDURE SetBlocker * (hc: HostController; blocker: Blocker);
|
|
|
+ BEGIN
|
|
|
+ hc.block := blocker
|
|
|
+ END SetBlocker;
|
|
|
+
|
|
|
+ (** Turns the busy LED on or off *)
|
|
|
+ PROCEDURE SetLedState * (hc: HostController; on: BOOLEAN);
|
|
|
+ VAR
|
|
|
+ reg: SET;
|
|
|
+ BEGIN
|
|
|
+ reg := SYSTEM.VAL(SET, hc.regs.HostControl1);
|
|
|
+ IF on THEN
|
|
|
+ INCL(reg, HostControl1_LedControl)
|
|
|
+ ELSE
|
|
|
+ EXCL(reg, HostControl1_LedControl)
|
|
|
+ END;
|
|
|
+ hc.regs.HostControl1 := SYSTEM.VAL(SHORTINT, reg)
|
|
|
+ END SetLedState;
|
|
|
+
|
|
|
+ (** Get the state of the busy LED *)
|
|
|
+ PROCEDURE GetLedState * (hc: HostController): BOOLEAN;
|
|
|
+ BEGIN
|
|
|
+ RETURN HostControl1_LedControl IN SYSTEM.VAL(SET, hc.regs.HostControl1)
|
|
|
+ END GetLedState;
|
|
|
+
|
|
|
+ (**
|
|
|
+ Execute the command 'command', without data transfer. If you need data transfer, use 'ExecuteDataCommand'.
|
|
|
+ Performs all necessary steps for executing a command:
|
|
|
+ o Runs CMD55 if command is an application command
|
|
|
+ o Execute the command
|
|
|
+ o Wait for response
|
|
|
+ *)
|
|
|
+ PROCEDURE ExecuteCommand (VAR command: Command; VAR result: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ status, r1: SET;
|
|
|
+ BEGIN
|
|
|
+ IF Synchronize THEN command.hc.acquire END;
|
|
|
+ result := ErrorNone;
|
|
|
+ (* Check Parameters *)
|
|
|
+ IF {FlagData, FlagRead, FlagAutoCmd12, FlagAutoCmd23, FlagMultipleBlockTx, FlagCountBlocks} * command.flags # {} THEN
|
|
|
+ result := ErrorInvalidParameters;
|
|
|
+ IF Synchronize THEN command.hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+
|
|
|
+ IF (FlagApplicationCmd IN command.flags) THEN
|
|
|
+ IF ~StartCommand(command.hc, CMD_APP_CMD, LSH(command.rca, 16), ResponseR1, FlagRead IN command.flags, FALSE, FALSE, FALSE, status, result) THEN
|
|
|
+ IF Synchronize THEN command.hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ r1 := GetR1(command);
|
|
|
+ IF EnableTrace THEN PrintCardStatus(r1) END;
|
|
|
+ IF ~(FlagIgnoreIllegalCmd IN command.flags) & (CardStatus_Error IN r1) THEN
|
|
|
+ result := ErrorCard;
|
|
|
+ IF Synchronize THEN command.hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END
|
|
|
+ END;
|
|
|
+
|
|
|
+ IF ~StartCommand(
|
|
|
+ command.hc, command.command, command.argument, command.responseType, FlagRead IN command.flags, FALSE,
|
|
|
+ FALSE (*command.responseType = ResponseR1b*), FlagAbort IN command.flags, status, result) THEN
|
|
|
+ IF Synchronize THEN command.hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ GetResponse(command.hc, command.responseType, command.response);
|
|
|
+ IF command.command = CMD_SELECT_DESELECT_CARD THEN
|
|
|
+ command.hc.lastRca := LSH(command.argument, -16)
|
|
|
+ ELSIF command.command = CMD_GO_IDLE_STATE THEN
|
|
|
+ command.hc.lastRca := 0
|
|
|
+ END;
|
|
|
+ IF Synchronize THEN command.hc.release END;
|
|
|
+ RETURN TRUE
|
|
|
+ END ExecuteCommand;
|
|
|
+
|
|
|
+ (**
|
|
|
+ Execute command with data transfer using CPU.
|
|
|
+ Data is read from/written to [data[ofs], data[ofs + len]).
|
|
|
+ *)
|
|
|
+ PROCEDURE ExecuteDataCommand (VAR command: Command; VAR data: ARRAY OF SYSTEM.BYTE; ofs, len: LONGINT; VAR result: LONGINT): BOOLEAN;
|
|
|
+ TYPE
|
|
|
+ DataBytes = ARRAY 4 OF CHAR;
|
|
|
+ VAR
|
|
|
+ tmp: DataBytes;
|
|
|
+ i, stepLen: LONGINT;
|
|
|
+ hc: HostController;
|
|
|
+ r1, status, mask: SET;
|
|
|
+ BEGIN
|
|
|
+ ASSERT(ofs + len <= LEN(data), 7);
|
|
|
+ result := ErrorNone;
|
|
|
+ IF ~(FlagData IN command.flags) THEN
|
|
|
+ result := ErrorInvalidParameters;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ hc := command.hc;
|
|
|
+
|
|
|
+ IF Synchronize THEN hc.acquire END;
|
|
|
+ (* Set timeout *)
|
|
|
+ SetTimeout(hc, command.dataTimeout);
|
|
|
+ (*IF (*~Reset(hc, TRUE, FALSE) OR*) ~Reset(hc, FALSE, TRUE) THEN
|
|
|
+ result := ErrorCard;
|
|
|
+ IF Synchronize THEN hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;*)
|
|
|
+
|
|
|
+ IF (FlagApplicationCmd IN command.flags) THEN
|
|
|
+ IF ~StartCommand(hc, CMD_APP_CMD, LSH(command.rca, 16), ResponseR1, FlagRead IN command.flags, FALSE, FALSE, FALSE, status, result) THEN
|
|
|
+ IF Synchronize THEN hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ r1 := SYSTEM.VAL(SET, command.response[0]);
|
|
|
+ IF CardStatus_Error IN r1 THEN
|
|
|
+ IF Synchronize THEN hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] CMD55 Status:");
|
|
|
+ Log.Ln;
|
|
|
+ PrintCardStatus(r1)
|
|
|
+ END
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* 1 *)
|
|
|
+ IF ~(FlagApplicationCmd IN command.flags) &
|
|
|
+ ((command.command = CMD_READ_SINGLE_BLOCK) OR (command.command = CMD_READ_MULTIPLE_BLOCK) OR
|
|
|
+ (command.command = CMD_WRITE_BLOCK) OR (command.command = CMD_WRITE_MULTIPLE_BLOCK) OR
|
|
|
+ (command.command = 53)(* SDIO Command *)) THEN
|
|
|
+ IF len <= BlockSize THEN
|
|
|
+ hc.regs.BlockSize := INTEGER(len);
|
|
|
+ hc.regs.BlockCount := 1
|
|
|
+ ELSE
|
|
|
+ hc.regs.BlockSize := BlockSize;
|
|
|
+ hc.regs.BlockCount := INTEGER(len DIV BlockSize)
|
|
|
+ END;
|
|
|
+
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] ");
|
|
|
+ IF FlagRead IN command.flags THEN Log.String("Read")
|
|
|
+ ELSE Log.String("Write") END;
|
|
|
+ Log.String(" parameters:"); Log.Ln;
|
|
|
+ Log.String("[SD] Block Size = "); Log.Int(hc.regs.BlockSize, 0); Log.Ln;
|
|
|
+ Log.String("[SD] Block Count = "); Log.Int(hc.regs.BlockCount, 0); Log.Ln;
|
|
|
+ Log.String("[SD] CMD"); Log.Int(command.command, 0); Log.Ln;
|
|
|
+ Log.String("[SD] Argument = "); Log.Address(command.argument); Log.Ln
|
|
|
+ END
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* 3 - 8 *)
|
|
|
+ IF FlagRead IN command.flags THEN
|
|
|
+ (*REPEAT UNTIL (Interrupt_Normal_BufferReadReady IN hc.regs.InterruptStatus) OR (Interrupt_Normal_ErrorInterrupt IN hc.regs.InterruptStatus)*)
|
|
|
+ mask := {Interrupt_Normal_BufferReadReady, Interrupt_Normal_ErrorInterrupt}
|
|
|
+ ELSE
|
|
|
+ (*REPEAT UNTIL (Interrupt_Normal_BufferWriteReady IN hc.regs.InterruptStatus) OR (Interrupt_Normal_ErrorInterrupt IN hc.regs.InterruptStatus)*)
|
|
|
+ mask := {Interrupt_Normal_BufferWriteReady, Interrupt_Normal_ErrorInterrupt}
|
|
|
+ END;
|
|
|
+
|
|
|
+ IF ~StartCommand(hc, command.command, command.argument, ResponseR1, FlagRead IN command.flags, FALSE, TRUE, FALSE, status, result) THEN RETURN FALSE END;
|
|
|
+ r1 := SYSTEM.VAL(SET, command.response[0]);
|
|
|
+ IF CardStatus_Error IN r1 THEN
|
|
|
+ IF Synchronize THEN hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ IF EnableTrace THEN PrintCardStatus(r1) END;
|
|
|
+ WHILE len > 0 DO
|
|
|
+ (* 14 *)
|
|
|
+ IF ~hc.block(hc, mask, command.dataTimeout * 1000) THEN
|
|
|
+ Log.String("[SD] Error: interrupt timeout");
|
|
|
+ Log.Ln;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ status := hc.regs.InterruptStatus;
|
|
|
+
|
|
|
+ IF Interrupt_Normal_ErrorInterrupt IN hc.regs.InterruptStatus THEN
|
|
|
+ IF ErrorRecovery(hc, result, status) THEN END;
|
|
|
+ IF Interrupt_Error_DataTimeout IN status THEN
|
|
|
+ result := ErrorDatTimeout
|
|
|
+ ELSIF Interrupt_Error_DataCrc IN status THEN
|
|
|
+ result := ErrorDatCrc
|
|
|
+ ELSIF Interrupt_Error_DataEndBit IN status THEN
|
|
|
+ result := ErrorCard
|
|
|
+ END;
|
|
|
+ IF Synchronize THEN hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ (* 15 *)
|
|
|
+ (*INCL(hc.regs.InterruptStatus, Interrupt_Normal_BufferReadReady);*)
|
|
|
+ hc.regs.InterruptStatus := {Interrupt_Normal_BufferReadReady};
|
|
|
+
|
|
|
+ (* 16 *)
|
|
|
+ stepLen := MIN(BlockSize, len);
|
|
|
+ IF FlagRead IN command.flags THEN
|
|
|
+ FOR i := 0 TO stepLen - 1 BY 4 DO
|
|
|
+ SYSTEM.PUT32(ADDRESSOF(data[ofs + i]), hc.regs.BufferData);
|
|
|
+ (*SYSTEM.VAL(LONGINT, tmp) := hc.regs.BufferData;
|
|
|
+ SYSTEM.VAL(DataBytes, data[ofs + i]) := tmp*)
|
|
|
+ END
|
|
|
+ ELSE
|
|
|
+ FOR i := 0 TO stepLen - 1 BY 4 DO
|
|
|
+ tmp := SYSTEM.VAL(DataBytes, data[ofs + i]);
|
|
|
+ hc.regs.BufferData := SYSTEM.VAL(LONGINT, tmp);
|
|
|
+ END
|
|
|
+ END;
|
|
|
+ (* 17 *)
|
|
|
+ INC(ofs, stepLen);
|
|
|
+ DEC(len, stepLen)
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* 18 -> Not infinite block *)
|
|
|
+ (*REPEAT UNTIL Interrupt_Normal_TransferComplete IN hc.regs.InterruptStatus;*)
|
|
|
+ IF ~hc.block(hc, {Interrupt_Normal_TransferComplete}, command.dataTimeout * 1000) THEN
|
|
|
+ Log.String("[SD] Error: timeout interrupt");
|
|
|
+ Log.Ln;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ (* 19 *)
|
|
|
+ (*INCL(hc.regs.InterruptStatus, Interrupt_Normal_TransferComplete);*)
|
|
|
+ hc.regs.InterruptStatus := {Interrupt_Normal_TransferComplete};
|
|
|
+
|
|
|
+ (*DEC(hc.regs.ClockControl, LSH(1, ClockControl_SdClockEnable));
|
|
|
+ hc.regs.SoftwareReset := SYSTEM.VAL(SHORTINT, {SoftwareResetCmd, SoftwareResetDat});
|
|
|
+ REPEAT UNTIL hc.regs.SoftwareReset = 0;
|
|
|
+ INC(hc.regs.ClockControl, LSH(1, ClockControl_SdClockEnable));*)
|
|
|
+
|
|
|
+ IF Synchronize THEN hc.release END;
|
|
|
+ RETURN TRUE (*Reset(hc, TRUE, FALSE) & Reset(hc, FALSE, TRUE)*)
|
|
|
+ END ExecuteDataCommand;
|
|
|
+
|
|
|
+ (**
|
|
|
+ Execute Command with data transfers using ADMA.
|
|
|
+ command: ADMA command
|
|
|
+ data, ofs, len: Buffer
|
|
|
+ result: error code
|
|
|
+ *)
|
|
|
+ PROCEDURE ExecuteAdmaCommand (VAR command: Command; VAR data: ARRAY OF SYSTEM.BYTE; ofs, len: LONGINT; VAR result: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ tt: SdEnvironment.Time;
|
|
|
+ hc: HostController;
|
|
|
+ r1, status, flags: SET;
|
|
|
+ address, a: ADDRESS;
|
|
|
+ blocks, blockSize, desc, txlen, l, tx: LONGINT;
|
|
|
+ padd: BOOLEAN; (* Padd transfer to next block length? *)
|
|
|
+
|
|
|
+ PROCEDURE WriteAdma2Desc (address: ADDRESS; len: LONGINT; flags: SET): HUGEINT;
|
|
|
+ BEGIN
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] ADMA2 Entry; address = "); Log.Hex(address, -8); Log.String(", size = "); Log.Int(len, 0);
|
|
|
+ Log.String(", flags = ");
|
|
|
+ IF flags * Adma2ActMask = Adma2Nop THEN Log.String("NOP ")
|
|
|
+ ELSIF flags * Adma2ActMask = Adma2Trans THEN Log.String("TRANS ")
|
|
|
+ ELSIF flags * Adma2ActMask = Adma2Link THEN Log.String("LINK ")
|
|
|
+ END;
|
|
|
+ IF Adma2Valid IN flags THEN Log.String("VALID ") END;
|
|
|
+ IF Adma2End IN flags THEN Log.String("END ") END;
|
|
|
+ IF Adma2Int IN flags THEN Log.String("INT ") END;
|
|
|
+ Log.Ln
|
|
|
+ END;
|
|
|
+ ASSERT(address MOD 4 = 0);
|
|
|
+ ASSERT((len > 0) OR (flags * Adma2ActMask # Adma2Trans));
|
|
|
+ RETURN LSH(HUGEINT(address), 32) + LSH(len MOD 65536, 16) + SYSTEM.VAL(LONGINT, flags)
|
|
|
+ END WriteAdma2Desc;
|
|
|
+
|
|
|
+ BEGIN
|
|
|
+ result := ErrorNone;
|
|
|
+ hc := command.hc;
|
|
|
+ IF Synchronize THEN hc.acquire END;
|
|
|
+
|
|
|
+ (* Setup descriptors *)
|
|
|
+ address := ADDRESSOF(data[ofs]);
|
|
|
+ (*IF ~(FlagRead IN command.flags) THEN*) SdEnvironment.FlushDCacheRange(address, len); (*END;*)
|
|
|
+ txlen := len;
|
|
|
+ flags := Adma2Trans + {Adma2Valid};
|
|
|
+ padd := FALSE; (*(len > BlockSize) & (len MOD BlockSize # 0);*)
|
|
|
+ l := len;
|
|
|
+ a := address;
|
|
|
+ WHILE l > 0 DO
|
|
|
+ IF ~padd & (l <= 65536) THEN flags := flags + {Adma2End, Adma2Int} END;
|
|
|
+ tx := MIN(l, 65536);
|
|
|
+ hc.desc[desc] := WriteAdma2Desc(a, tx, flags);
|
|
|
+ DEC(l, tx);
|
|
|
+ INC(a, tx);
|
|
|
+ INC(desc);
|
|
|
+ END;
|
|
|
+ (*hc.desc[desc] := WriteAdma2Desc(0, 0, {Adma2Valid, Adma2End, Adma2Int} + Adma2Nop); INC(desc);*)
|
|
|
+ SdEnvironment.FlushDCacheRange(ADDRESSOF(hc.desc[0]), (desc + 1) * 8);
|
|
|
+
|
|
|
+ (* Reset command and data lines *)
|
|
|
+ IF (*~Reset(hc, TRUE, FALSE) OR*) ~Reset(hc, FALSE, TRUE) THEN
|
|
|
+ result := ErrorCard;
|
|
|
+ IF Synchronize THEN hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* 1 *)
|
|
|
+ hc.regs.AdmaSystemAddress := ADDRESSOF(hc.desc[0]);
|
|
|
+
|
|
|
+ IF (FlagApplicationCmd IN command.flags) THEN
|
|
|
+ IF ~StartCommand(command.hc, CMD_APP_CMD, LSH(command.rca, 16), ResponseR1, FlagRead IN command.flags, FALSE, FALSE, FALSE, status, result) THEN
|
|
|
+ IF Synchronize THEN hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ r1 := SYSTEM.VAL(SET, command.response[0]);
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] CMD55 Status:");
|
|
|
+ Log.Ln;
|
|
|
+ PrintCardStatus(r1)
|
|
|
+ END;
|
|
|
+ IF CardStatus_Error IN r1 THEN
|
|
|
+ result := ErrorCard;
|
|
|
+ IF Synchronize THEN hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* 2-3 *)
|
|
|
+ IF command.blockSize = 0 THEN
|
|
|
+ blockSize := BlockSize
|
|
|
+ ELSE
|
|
|
+ blockSize := command.blockSize
|
|
|
+ END;
|
|
|
+ IF FlagData IN command.flags THEN
|
|
|
+ IF txlen <= blockSize THEN
|
|
|
+ hc.regs.BlockSize := INTEGER(txlen);
|
|
|
+ hc.regs.BlockCount := 1;
|
|
|
+ blocks := 1
|
|
|
+ ELSE
|
|
|
+ hc.regs.BlockSize := INTEGER(blockSize);
|
|
|
+ blocks := txlen DIV blockSize;
|
|
|
+ hc.regs.BlockCount := INTEGER(blocks)
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* Set data timeout *)
|
|
|
+ ASSERT(command.dataTimeout > 0);
|
|
|
+ SetTimeout(hc, command.dataTimeout);
|
|
|
+
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] ");
|
|
|
+ IF FlagRead IN command.flags THEN Log.String("Read")
|
|
|
+ ELSE Log.String("Write") END;
|
|
|
+ Log.String(" parameters:"); Log.Ln;
|
|
|
+ Log.String("[SD] Block Size = "); Log.Int(hc.regs.BlockSize, 0); Log.Ln;
|
|
|
+ Log.String("[SD] Block Count = "); Log.Int(hc.regs.BlockCount, 0); Log.Ln;
|
|
|
+ Log.String("[SD] CMD"); Log.Int(command.command, 0); Log.Ln;
|
|
|
+ Log.String("[SD] Argument = "); Log.Address(command.argument); Log.Ln
|
|
|
+ END
|
|
|
+ END;
|
|
|
+
|
|
|
+ status := hc.regs.InterruptStatus;
|
|
|
+ ASSERT({Interrupt_Normal_TransferComplete, Interrupt_Normal_ErrorInterrupt} * status = {});
|
|
|
+ (*!start := SdEnvironment.GetTimeCounter();*)
|
|
|
+ IF ~StartCommand(command.hc, command.command, command.argument, command.responseType, FlagRead IN command.flags, TRUE, TRUE, FALSE, status, result) THEN
|
|
|
+ IF Synchronize THEN hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ r1 := SYSTEM.VAL(SET, command.response[0]);
|
|
|
+ IF CardStatus_Error IN r1 THEN
|
|
|
+ result := ErrorCard;
|
|
|
+ IF Synchronize THEN hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ IF EnableTrace THEN PrintCardStatus(r1) END;
|
|
|
+
|
|
|
+ (*t := SdEnvironment.GetTimeCounter();
|
|
|
+ tt := t + SdEnvironment.FromMilli(1000);*)
|
|
|
+ (*WHILE ({Interrupt_Normal_TransferComplete, Interrupt_Normal_ErrorInterrupt, Interrupt_Error_Adma} * status = {}) (*& (SdEnvironment.GetTimeCounter() <= tt)*) DO
|
|
|
+ status := hc.regs.InterruptStatus
|
|
|
+ END;*)
|
|
|
+ (*IF SdEnvironment.GetTimeCounter() > tt(*{Interrupt_Normal_TransferComplete, Interrupt_Normal_ErrorInterrupt} * status = {}*) THEN*)
|
|
|
+ IF ~hc.block(hc, {Interrupt_Normal_TransferComplete, Interrupt_Normal_ErrorInterrupt}, command.dataTimeout * 1000) THEN
|
|
|
+ Log.String("[SD] Error: timeout has expired!"); Log.Ln;
|
|
|
+ PrintHcRegisters(hc.regs);
|
|
|
+ IF Synchronize THEN hc.release END;
|
|
|
+ HALT(512);
|
|
|
+ RETURN FALSE;
|
|
|
+ END;
|
|
|
+ (*!stop := SdEnvironment.GetTimeCounter();*)
|
|
|
+ status := hc.regs.InterruptStatus;
|
|
|
+
|
|
|
+ IF Interrupt_Normal_ErrorInterrupt IN status THEN
|
|
|
+ IF ErrorRecovery(hc, result, status) THEN END;
|
|
|
+ IF Interrupt_Error_DataTimeout IN status THEN
|
|
|
+ result := ErrorDatTimeout;
|
|
|
+ IF ~Reset(hc, FALSE, TRUE) THEN END
|
|
|
+ ELSIF Interrupt_Error_DataCrc IN status THEN
|
|
|
+ result := ErrorDatCrc
|
|
|
+ ELSIF Interrupt_Error_DataEndBit IN status THEN
|
|
|
+ result := ErrorCard
|
|
|
+ ELSIF Interrupt_Error_Adma IN status THEN
|
|
|
+ HALT(182)
|
|
|
+ END;
|
|
|
+ IF Synchronize THEN hc.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ hc.regs.InterruptStatus := status;
|
|
|
+ IF FlagRead IN command.flags THEN
|
|
|
+ SdEnvironment.InvalidateDCacheRange(address, len)
|
|
|
+ END;
|
|
|
+ (*!IF FlagRead IN command.flags THEN
|
|
|
+ INC(Tread, stop - start);
|
|
|
+ ELSE
|
|
|
+ INC(Twrite, stop - start);
|
|
|
+ END;*)
|
|
|
+ IF Synchronize THEN hc.release END;
|
|
|
+ RETURN TRUE
|
|
|
+ END ExecuteAdmaCommand;
|
|
|
+
|
|
|
+ (** Get the response registers in 'response' *)
|
|
|
+ PROCEDURE GetResponse (hc: HostController; responseType: LONGINT; VAR response: ARRAY 4 OF LONGINT);
|
|
|
+ BEGIN
|
|
|
+ response := hc.regs.Response
|
|
|
+ END GetResponse;
|
|
|
+
|
|
|
+ (** Issue an SD Card Transaction. [Simplified specs. 3.7.1.1 pp. 106-108] *)
|
|
|
+ PROCEDURE StartCommand (hc: HostController; cmd, argument, responseType: LONGINT; read, dma, busy, abort: BOOLEAN; VAR status: SET; VAR result: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ t: HUGEINT;
|
|
|
+ reg: LONGINT;
|
|
|
+ flags, txFlags: SET;
|
|
|
+ BEGIN
|
|
|
+ IF EnableTraceCmd THEN
|
|
|
+ Log.String("[SD] Sending Command CMD"); Log.Int(cmd, 0); Log.Ln;
|
|
|
+ Log.String("[SD] Argument: "); Log.Hex(argument, -8); Log.Ln
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* 1 *)
|
|
|
+ t := SdEnvironment.GetTimeCounter() + SdEnvironment.FromMilli(1000);
|
|
|
+ WHILE (PresentState_CommandInhibitCmd IN hc.regs.PresentState) & (t > SdEnvironment.GetTimeCounter()) DO END;
|
|
|
+ IF t < SdEnvironment.GetTimeCounter() THEN
|
|
|
+ Log.String("[SD] Timeout error in StartCommand (1)");
|
|
|
+ Log.Ln;
|
|
|
+ PrintHcRegisters(hc);
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* 2 *)
|
|
|
+ IF busy THEN
|
|
|
+ (* 3 *)
|
|
|
+ IF ~abort THEN
|
|
|
+ (* 4 *)
|
|
|
+ t := SdEnvironment.GetTimeCounter() + SdEnvironment.FromMilli(1000);
|
|
|
+ WHILE (PresentState_CommandInhibitDat IN hc.regs.PresentState) & (t > SdEnvironment.GetTimeCounter()) DO END;
|
|
|
+ IF t < SdEnvironment.GetTimeCounter() THEN
|
|
|
+ Log.String("[SD] Timeout error in StartCommand (2)");
|
|
|
+ Log.Ln;
|
|
|
+ PrintHcRegisters(hc);
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ END
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* 5 *)
|
|
|
+ hc.regs.Argument1 := argument;
|
|
|
+
|
|
|
+ (* 6 *)
|
|
|
+ (* The response type determines the response-type and CRC/Index checks enabling *)
|
|
|
+ CASE responseType OF
|
|
|
+ ResponseNone:
|
|
|
+ reg := Command_ResponseType_None;
|
|
|
+ IF EnableTraceCmd THEN
|
|
|
+ Log.String("[SD] No Response Expected");
|
|
|
+ Log.Ln
|
|
|
+ END
|
|
|
+ |ResponseR1, ResponseR5, ResponseR6, ResponseR7:
|
|
|
+ reg := Command_ResponseType_48b;
|
|
|
+ flags := {Command_CrcCheckEnable, Command_IndexCheckEnable};
|
|
|
+ IF EnableTraceCmd THEN
|
|
|
+ Log.String("[SD] 48 Bit Response"); Log.Ln;
|
|
|
+ Log.String("[SD] Enabling CRC Check and Index Check"); Log.Ln
|
|
|
+ END
|
|
|
+ |ResponseR3, ResponseR4:
|
|
|
+ reg := Command_ResponseType_48b;
|
|
|
+ IF EnableTraceCmd THEN Log.String("[SD] 48 Bit Response"); Log.Ln END
|
|
|
+ |ResponseR1b, ResponseR5b:
|
|
|
+ reg := Command_ResponseType_48bBusy;
|
|
|
+ flags := {Command_CrcCheckEnable, Command_IndexCheckEnable};
|
|
|
+ IF EnableTraceCmd THEN
|
|
|
+ Log.String("[SD] 48 Bit Response"); Log.Ln;
|
|
|
+ Log.String("[SD] Enabling Index Check"); Log.Ln
|
|
|
+ END
|
|
|
+ |ResponseR2:
|
|
|
+ reg := Command_ResponseType_136b;
|
|
|
+ flags := {Command_CrcCheckEnable};
|
|
|
+ IF EnableTraceCmd THEN
|
|
|
+ Log.String("[SD] 136 Bit Response"); Log.Ln;
|
|
|
+ Log.String("[SD] Enabling Command CRC Check"); Log.Ln
|
|
|
+ END
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* Command determines data-enable *)
|
|
|
+ IF busy THEN
|
|
|
+ INCL(flags, Command_DataPresent);
|
|
|
+ IF EnableTraceCmd THEN Log.String("[SD] Using DAT Line"); Log.Ln END;
|
|
|
+
|
|
|
+ txFlags := {};
|
|
|
+ IF (*(cmd = CMD_READ_SINGLE_BLOCK) OR (cmd = CMD_READ_MULTIPLE_BLOCK) OR (cmd = ACMD_SEND_SCR)*) read THEN
|
|
|
+ IF EnableTraceCmd THEN Log.String("[SD] Data Read"); Log.Ln END;
|
|
|
+ INCL(txFlags, TransferMode_DataTxDirection)
|
|
|
+ ELSIF EnableTraceCmd THEN
|
|
|
+ Log.String("[SD] Data Write");
|
|
|
+ Log.Ln
|
|
|
+ END;
|
|
|
+ IF (cmd = CMD_READ_MULTIPLE_BLOCK) OR (cmd = CMD_WRITE_MULTIPLE_BLOCK) THEN
|
|
|
+ IF EnableTraceCmd THEN Log.String("[SD] Multiple blocks: using Auto CMD12 & activating block count"); Log.Ln END;
|
|
|
+ txFlags := txFlags + TransferMode_AutoCmd_Cmd12 + {TransferMode_MultipleBlocks, TransferMode_BlockCountEnable}
|
|
|
+ ELSIF EnableTraceCmd THEN
|
|
|
+ Log.String("[SD] Single Block");
|
|
|
+ Log.Ln
|
|
|
+ END;
|
|
|
+ IF dma THEN INCL(txFlags, TransferMode_DmaEnable) END;
|
|
|
+ hc.regs.TransferMode := SYSTEM.VAL(INTEGER, txFlags)
|
|
|
+ END;
|
|
|
+ hc.regs.Command := SYSTEM.VAL(INTEGER, SYSTEM.VAL(SET, reg + LSH(cmd, Command_CommandIndexOffset)) + flags);
|
|
|
+
|
|
|
+ (* 7 *)
|
|
|
+ RETURN WaitForCompletion(hc, ~abort, status, result)
|
|
|
+ (* Steps 7, 8 and 9 of WaitForCompletion have to be done by caller *)
|
|
|
+ END StartCommand;
|
|
|
+
|
|
|
+ (**
|
|
|
+ Perform error recovery as specified by the triggered error interrupts.
|
|
|
+ Returns an error code (result) and the interrupt status register before recovery (status)
|
|
|
+ *)
|
|
|
+ PROCEDURE ErrorRecovery (hc: HostController; VAR result: LONGINT; VAR status: SET): BOOLEAN;
|
|
|
+ BEGIN
|
|
|
+ (* 1 is done *)
|
|
|
+ status := hc.regs.InterruptStatus;
|
|
|
+ hc.regs.InterruptStatusEnable := {0 .. 14};
|
|
|
+ EXCL(hc.regs.InterruptStatusEnable, Interrupt_Normal_ErrorInterrupt);
|
|
|
+ EXCL(hc.regs.InterruptStatusEnable, Interrupt_Normal_ErrorInterrupt);
|
|
|
+ EXCL(hc.regs.InterruptStatusEnable, Interrupt_Normal_ErrorInterrupt);
|
|
|
+
|
|
|
+ (* 2 *)
|
|
|
+ IF (Interrupt_Error_CommandTimeout IN status) OR (Interrupt_Error_CommandCrc IN status) OR (Interrupt_Error_CommandEndBit IN status)
|
|
|
+ OR (Interrupt_Error_CommandIndex IN status) THEN
|
|
|
+ (* 3 & 4 *)
|
|
|
+ IF ~Reset(hc, TRUE, FALSE) THEN
|
|
|
+ result := ErrorUnrecoverable;
|
|
|
+ RETURN FALSE
|
|
|
+ END
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* 5 *)
|
|
|
+ IF Interrupt_Error_DataTimeout IN status THEN
|
|
|
+ Log.String("[SD] Got data timeout error"); Log.Ln
|
|
|
+ END;
|
|
|
+ IF (Interrupt_Error_DataTimeout IN status) OR (Interrupt_Error_DataCrc IN status) OR (Interrupt_Error_DataEndBit IN status) THEN
|
|
|
+ (* 6 & 7 *)
|
|
|
+ IF ~Reset(hc, FALSE, TRUE) THEN
|
|
|
+ result := ErrorUnrecoverable;
|
|
|
+ RETURN FALSE
|
|
|
+ END
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* 8 & 9 *)
|
|
|
+ hc.regs.InterruptStatus := status;
|
|
|
+
|
|
|
+ (* 10 & 11 *)
|
|
|
+ (*IF ~Command(hc, CMD_STOP_TRANSMISSION, 0, ResponseR1b, FALSE, TRUE, result) THEN
|
|
|
+ (* 12 *)
|
|
|
+ IF (Interrupt_Error_CommandTimeout IN status) OR (Interrupt_Error_CommandCrc IN status) OR (Interrupt_Error_CommandEndBit IN status)
|
|
|
+ OR (Interrupt_Error_CommandIndex IN status) THEN
|
|
|
+ TRACE('CMD12 CMD LINE ERROR');
|
|
|
+ result := ErrorUnrecoverable;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ (* 13 *)
|
|
|
+ IF ~WaitForTransfer(hc, result) THEN
|
|
|
+ result := ErrorUnrecoverable;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ TRACE(hc.regs.BufferData);
|
|
|
+ END;
|
|
|
+ (* 15 *)
|
|
|
+ IF hc.regs.PresentState * PresentState_DatLineSignalLevelMask # PresentState_DatLineSignalLevelMask THEN
|
|
|
+ TRACE('CMD12 DAT LINE ERROR');
|
|
|
+ result := ErrorUnrecoverable;
|
|
|
+ RETURN FALSE
|
|
|
+ END;*)
|
|
|
+ hc.regs.InterruptStatusEnable := {0 .. 31};
|
|
|
+ INCL(hc.regs.InterruptStatusEnable, Interrupt_Normal_ErrorInterrupt);
|
|
|
+ result := ErrorNone;
|
|
|
+ RETURN TRUE
|
|
|
+ END ErrorRecovery;
|
|
|
+
|
|
|
+ (** Wait for completion of an SD command [Simplified specs. 3.7.1.2 pp. 109-110 *)
|
|
|
+ PROCEDURE WaitForCompletion (hc: HostController; tryRecover: BOOLEAN; VAR status: SET; VAR result: LONGINT): BOOLEAN;
|
|
|
+ BEGIN
|
|
|
+ result := ErrorNone;
|
|
|
+
|
|
|
+ (* 1 *)
|
|
|
+ IF ~hc.block(hc, {Interrupt_Normal_CommandComplete, Interrupt_Normal_ErrorInterrupt}, DefaultTimeout) THEN
|
|
|
+ Log.String("[SD] Timeout while waiting for completion");
|
|
|
+ Log.Ln;
|
|
|
+ PrintHcRegisters(hc);
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ status := hc.regs.InterruptStatus;
|
|
|
+
|
|
|
+ IF Interrupt_Normal_ErrorInterrupt IN status THEN
|
|
|
+ IF ~tryRecover THEN
|
|
|
+ hc.regs.InterruptStatus := status;
|
|
|
+ result := ErrorUnrecoverable;
|
|
|
+ RETURN Reset(hc, TRUE, FALSE) & Reset(hc, FALSE, TRUE)
|
|
|
+ END;
|
|
|
+ IF ~ErrorRecovery(hc, result, status) THEN RETURN FALSE END;
|
|
|
+ IF Interrupt_Error_CommandTimeout IN status THEN
|
|
|
+ IF EnableTraceCmd THEN Log.String("[SD] Timeout in command"); Log.Ln END;
|
|
|
+ result := ErrorCmdTimeout;
|
|
|
+ IF ~Reset(hc, TRUE, FALSE) THEN END;
|
|
|
+ ELSIF Interrupt_Error_CommandCrc IN status THEN
|
|
|
+ result := ErrorCmdCrc;
|
|
|
+ ELSE
|
|
|
+ result := ErrorCard;
|
|
|
+ END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* 2 *)
|
|
|
+ hc.regs.InterruptStatus := {Interrupt_Normal_CommandComplete};
|
|
|
+
|
|
|
+ IF EnableTraceCmd THEN Log.String("[SD] Command successful"); Log.Ln END;
|
|
|
+ RETURN TRUE
|
|
|
+ END WaitForCompletion;
|
|
|
+
|
|
|
+ (** Wait for transfer complete interrupt *)
|
|
|
+ PROCEDURE WaitForTransfer (hc: HostController; VAR result: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ status: SET;
|
|
|
+ BEGIN
|
|
|
+ (* 5 *)
|
|
|
+ IF ~hc.block(hc, {Interrupt_Normal_TransferComplete, Interrupt_Normal_ErrorInterrupt}, DefaultTimeout) THEN
|
|
|
+ Log.String("[SD] Timeout failed in WaitForTransfer");
|
|
|
+ RETURN FALSE;
|
|
|
+ END;
|
|
|
+ (*REPEAT UNTIL (Interrupt_Normal_TransferComplete IN hc.regs.InterruptStatus) OR (Interrupt_Normal_ErrorInterrupt IN hc.regs.InterruptStatus);*)
|
|
|
+ status := hc.regs.InterruptStatus;
|
|
|
+
|
|
|
+ IF Interrupt_Normal_ErrorInterrupt IN hc.regs.InterruptStatus THEN
|
|
|
+ IF ~ErrorRecovery(hc, result, status) THEN RETURN FALSE END;
|
|
|
+ result := ErrorCard;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* 6 *)
|
|
|
+ (*INCL(hc.regs.InterruptStatus, Interrupt_Normal_TransferComplete)*)
|
|
|
+ hc.regs.InterruptStatus := {Interrupt_Normal_TransferComplete}
|
|
|
+ END WaitForTransfer;
|
|
|
+
|
|
|
+ PROCEDURE SpinBlock (hc: HostController; mask: SET; timeout: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ deadline: SdEnvironment.Time;
|
|
|
+ BEGIN
|
|
|
+ deadline := SdEnvironment.GetTimeCounter() + SdEnvironment.FromMilli(timeout);
|
|
|
+ REPEAT UNTIL (mask * hc.regs.InterruptStatus # {}) OR (SdEnvironment.GetTimeCounter() > deadline);
|
|
|
+ RETURN mask * hc.regs.InterruptStatus # {}
|
|
|
+ END SpinBlock;
|
|
|
+
|
|
|
+ (** Sends CMD7 if necessary to select the given card *)
|
|
|
+ PROCEDURE SelectCard * (hc: HostController; card: LONGINT; VAR result: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ command: Command;
|
|
|
+ status: SET;
|
|
|
+ BEGIN
|
|
|
+ result := ErrorNone;
|
|
|
+ IF hc.lastRca = card THEN
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] Card Already Selected");
|
|
|
+ Log.Ln
|
|
|
+ END;
|
|
|
+ RETURN TRUE
|
|
|
+ END;
|
|
|
+
|
|
|
+ IF EnableTrace THEN Log.String("[SD] Selecting Card "); Log.Int(card, 0); Log.Ln END;
|
|
|
+ command.hc := hc;
|
|
|
+ command.command := CMD_SELECT_DESELECT_CARD;
|
|
|
+ command.argument := LSH(card, 16);
|
|
|
+ command.responseType := ResponseR1b;
|
|
|
+ IF ~hc.execute(command, result) THEN RETURN FALSE END;
|
|
|
+ status := GetR1(command);
|
|
|
+ IF CardStatus_Error IN status THEN result := ErrorCard; RETURN FALSE END;
|
|
|
+ RETURN TRUE
|
|
|
+ END SelectCard;
|
|
|
+
|
|
|
+ (** Deselects all cards *)
|
|
|
+ PROCEDURE DeselectCards * (hc: HostController; VAR result: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ command: Command;
|
|
|
+ ignoreRes: LONGINT;
|
|
|
+ ignoreBool: BOOLEAN;
|
|
|
+ BEGIN
|
|
|
+ result := ErrorNone;
|
|
|
+ IF hc.lastRca = 0 THEN
|
|
|
+ IF EnableTrace THEN Log.String("[SD] No card selected"); Log.Ln END;
|
|
|
+ RETURN TRUE
|
|
|
+ END;
|
|
|
+
|
|
|
+ IF EnableTrace THEN Log.String("[SD] Deselecting cards"); Log.Ln END;
|
|
|
+ command.hc := hc;
|
|
|
+ command.command := CMD_SELECT_DESELECT_CARD;
|
|
|
+ command.responseType := ResponseR1b;
|
|
|
+ ignoreBool := hc.execute(command, ignoreRes);
|
|
|
+ hc.lastRca := 0;
|
|
|
+ RETURN TRUE
|
|
|
+ END DeselectCards;
|
|
|
+
|
|
|
+ (** Read response R1 or R1b from command record *)
|
|
|
+ PROCEDURE GetR1 * (CONST command: Command): SET;
|
|
|
+ VAR
|
|
|
+ idx: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ idx := 0;
|
|
|
+ (*IF (FlagAutoCmd12 IN command.flags) OR (FlagAutoCmd23 IN command.flags) THEN
|
|
|
+ idx := 3
|
|
|
+ END;*)
|
|
|
+ RETURN SYSTEM.VAL(SET, command.response[idx])
|
|
|
+ END GetR1;
|
|
|
+
|
|
|
+ (** Read response R2 from command record *)
|
|
|
+ PROCEDURE GetR2 * (CONST command: Command; VAR response: ARRAY OF LONGINT);
|
|
|
+ VAR
|
|
|
+ i: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ FOR i := 0 TO 3 DO
|
|
|
+ response[i] := command.response[i]
|
|
|
+ END
|
|
|
+ END GetR2;
|
|
|
+
|
|
|
+ (** Read response R3 from command record *)
|
|
|
+ PROCEDURE GetR3 * (CONST command: Command): LONGINT;
|
|
|
+ BEGIN
|
|
|
+ RETURN command.response[0]
|
|
|
+ END GetR3;
|
|
|
+
|
|
|
+ (** Read response R4 from command record *)
|
|
|
+ PROCEDURE GetR4 * (CONST command: Command): LONGINT;
|
|
|
+ BEGIN
|
|
|
+ RETURN command.response[0]
|
|
|
+ END GetR4;
|
|
|
+
|
|
|
+ (** Read response R5 from command record *)
|
|
|
+ PROCEDURE GetR5 * (CONST command: Command): LONGINT;
|
|
|
+ BEGIN
|
|
|
+ RETURN command.response[0]
|
|
|
+ END GetR5;
|
|
|
+
|
|
|
+ (** Read response R6 from command record *)
|
|
|
+ PROCEDURE GetR6 * (CONST command: Command): LONGINT;
|
|
|
+ BEGIN
|
|
|
+ RETURN command.response[0]
|
|
|
+ END GetR6;
|
|
|
+
|
|
|
+ (** Read response R7 from command record *)
|
|
|
+ PROCEDURE GetR7 * (CONST command: Command): LONGINT;
|
|
|
+ BEGIN
|
|
|
+ RETURN command.response[0]
|
|
|
+ END GetR7;
|
|
|
+
|
|
|
+ (** Reset command and/or data lines of a host controller *)
|
|
|
+ PROCEDURE Reset (hc: HostController; cmd, dat: BOOLEAN): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ val: SHORTINT;
|
|
|
+ BEGIN
|
|
|
+ IF cmd & dat THEN
|
|
|
+ val := SoftwareResetAll
|
|
|
+ ELSIF cmd THEN
|
|
|
+ val := SoftwareResetCmd
|
|
|
+ ELSIF dat THEN
|
|
|
+ val := SoftwareResetDat
|
|
|
+ ELSE
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ hc.regs.SoftwareReset := val;
|
|
|
+ REPEAT
|
|
|
+ UNTIL hc.regs.SoftwareReset # val;
|
|
|
+ RETURN TRUE
|
|
|
+ END Reset;
|
|
|
+
|
|
|
+ (** Set host controller bust clock *)
|
|
|
+ PROCEDURE SetBusClock (hc: HostController; freq: LONGINT);
|
|
|
+ VAR
|
|
|
+ val: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ hc.regs.ClockControl := 0;
|
|
|
+
|
|
|
+ IF freq < hc.baseFrequency THEN
|
|
|
+
|
|
|
+ val := 1;
|
|
|
+ WHILE (val < 8) & (LSH(hc.baseFrequency,-val) > freq) DO
|
|
|
+ INC(val);
|
|
|
+ END;
|
|
|
+
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String(" [SD] baseFreq=");
|
|
|
+ Log.Int(hc.baseFrequency, 0);
|
|
|
+ Log.String(", val=");
|
|
|
+ Log.Int(val, 0);
|
|
|
+ Log.Ln
|
|
|
+ END;
|
|
|
+
|
|
|
+ hc.regs.ClockControl := INTEGER(LSH(LSH(LONGINT(1), val-1), 8) + SYSTEM.VAL(INTEGER, {ClockControl_InternalClockEnable}));
|
|
|
+ hc.frequency := LSH(hc.baseFrequency, -val);
|
|
|
+ ELSE
|
|
|
+ hc.regs.ClockControl := SYSTEM.VAL(INTEGER, {ClockControl_InternalClockEnable});
|
|
|
+ hc.frequency := hc.baseFrequency;
|
|
|
+ END;
|
|
|
+
|
|
|
+ REPEAT val := hc.regs.ClockControl UNTIL ClockControl_InternalClockState IN SYSTEM.VAL(SET, val);
|
|
|
+ val := hc.regs.ClockControl;
|
|
|
+ hc.regs.ClockControl := SYSTEM.VAL(INTEGER, SYSTEM.VAL(SET, val) + {ClockControl_SdClockEnable});
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] Selecting Bus Clock Frequency: ");
|
|
|
+ Log.Int(hc.frequency, 0); Log.String(" Hz");
|
|
|
+ Log.Ln
|
|
|
+ END;
|
|
|
+ END SetBusClock;
|
|
|
+
|
|
|
+ (** Set host controller data timeout, in ms *)
|
|
|
+ PROCEDURE SetTimeout (hc: HostController; timeout: LONGINT);
|
|
|
+ VAR
|
|
|
+ ratio, val: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ EXCL(hc.regs.InterruptStatusEnable, Interrupt_Error_DataTimeout);
|
|
|
+ ratio := LSH(LONGINT(hc.timeoutFrequency * timeout DIV 1000), -13);
|
|
|
+ val := 0;
|
|
|
+ WHILE (val < 15) & (LSH(LONGINT(1), val) < ratio) DO INC(val) END;
|
|
|
+ ASSERT(LSH(LONGINT(1), val) >= ratio);
|
|
|
+ hc.regs.TimeoutControl := SYSTEM.VAL(SHORTINT, val);
|
|
|
+ INCL(hc.regs.InterruptStatusEnable, Interrupt_Error_DataTimeout)
|
|
|
+ END SetTimeout;
|
|
|
+
|
|
|
+ (** Set the data bus width for a given RCA. *)
|
|
|
+ PROCEDURE SetBusWidth (hc: HostController; card: Card; width: LONGINT; VAR result: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ command: Command;
|
|
|
+ val: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ IF ~SelectCard(card.hc, card.rca, result) THEN RETURN FALSE END;
|
|
|
+
|
|
|
+ (*command.hc := card.hc;
|
|
|
+ command.command := ACMD_SET_CLR_CARD_DETECT;
|
|
|
+ command.argument := 0;
|
|
|
+ command.responseType := ResponseR1;
|
|
|
+ command.flags := {FlagApplicationCmd};
|
|
|
+ command.rca := card.rca;
|
|
|
+ IF ~ExecuteCommand(command, result) THEN RETURN FALSE END;*)
|
|
|
+
|
|
|
+ (* 1 *)
|
|
|
+ EXCL(hc.regs.InterruptStatusEnable, Interrupt_Normal_CardInterrupt);
|
|
|
+
|
|
|
+ (* 2: driver supports SD cards only *)
|
|
|
+ (* 3: not implemented *)
|
|
|
+
|
|
|
+ (* 4 *)
|
|
|
+ command.command := ACMD_SET_BUS_WIDTH;
|
|
|
+ CASE width OF
|
|
|
+ 1: command.argument := 0
|
|
|
+ |4: command.argument := 2
|
|
|
+ END;
|
|
|
+ command.hc := hc;
|
|
|
+ command.rca := card.rca;
|
|
|
+ command.flags := {FlagApplicationCmd};
|
|
|
+ command.responseType := ResponseR1;
|
|
|
+ IF ~ExecuteCommand(command, result) THEN RETURN FALSE END;
|
|
|
+
|
|
|
+ (* 5 *)
|
|
|
+ val := hc.regs.HostControl1;
|
|
|
+ CASE width OF
|
|
|
+ 1: EXCL(SYSTEM.VAL(SET, val), HostControl1_DataTransferWidth)
|
|
|
+ |4: INCL(SYSTEM.VAL(SET, val), HostControl1_DataTransferWidth)
|
|
|
+ END;
|
|
|
+ hc.regs.HostControl1 := SHORTINT(val);
|
|
|
+
|
|
|
+ (* 6: SD card only *)
|
|
|
+ (* 8 *)
|
|
|
+ INCL(hc.regs.InterruptStatusEnable, Interrupt_Normal_CardInterrupt);
|
|
|
+ RETURN TRUE
|
|
|
+ END SetBusWidth;
|
|
|
+
|
|
|
+ (** Executes a switch function command *)
|
|
|
+ PROCEDURE SwitchFunc (card: Card; switch: BOOLEAN; funcs: ARRAY 6 OF LONGINT; VAR sts: SwitchFuncStatus; VAR res: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ status: ARRAY 64 OF CHAR;
|
|
|
+ command: Command;
|
|
|
+
|
|
|
+ PROCEDURE GetStatus (CONST status: ARRAY OF CHAR; VAR sts: SwitchFuncStatus);
|
|
|
+ VAR
|
|
|
+ i: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ sts.current := LONGINT(ORD(status[0])) * 100H + LONGINT(ORD(status[1]));
|
|
|
+ FOR i := 0 TO 5 DO
|
|
|
+ sts.functionGroups[i] := SYSTEM.VAL(SET, LONGINT(ORD(status[2 + 2 * (5 - i)])) * 100H + LONGINT(ORD(status[1 + 2 + 2 * (5 - i)])))
|
|
|
+ END;
|
|
|
+ FOR i := 0 TO 5 BY 2 DO
|
|
|
+ sts.functionStatus[i] := ORD(status[14 + 2 - i DIV 2]) MOD 10H;
|
|
|
+ sts.functionStatus[i + 1] := ORD(status[14 + 2 - i DIV 2]) DIV 10H
|
|
|
+ END;
|
|
|
+ END GetStatus;
|
|
|
+
|
|
|
+ BEGIN
|
|
|
+ IF ~SelectCard(card.hc, card.rca, res) THEN RETURN FALSE END;
|
|
|
+ command.hc := card.hc;
|
|
|
+ command.command := CMD_SWITCH_FUNC;
|
|
|
+ command.responseType := ResponseR1;
|
|
|
+ command.argument := (funcs[0] MOD 10H) + 10H * (funcs[1] MOD 10H) + 100H * (funcs[2] MOD 10H) + 1000H * (funcs[3] MOD 10H) + 10000H * (funcs[4] MOD 10H) + 100000H * (funcs[5] MOD 10H);
|
|
|
+ IF switch THEN INCL(SYSTEM.VAL(SET, command.argument), 31) END;
|
|
|
+ command.flags := {FlagRead, FlagData};
|
|
|
+ command.dataTimeout := card.readTimeout;
|
|
|
+ IF ~card.hc.transfer(command, status, 0, 64, res) THEN RETURN FALSE END;
|
|
|
+ GetStatus(status, sts);
|
|
|
+ RETURN TRUE
|
|
|
+ END SwitchFunc;
|
|
|
+
|
|
|
+ (** Outputs the switch function status on the log *)
|
|
|
+ PROCEDURE PrintSwitchFuncStatus(CONST status: SwitchFuncStatus);
|
|
|
+ VAR
|
|
|
+ i: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ Log.String("Switch Func Status");
|
|
|
+ Log.Ln;
|
|
|
+ Log.String("Current = ");
|
|
|
+ IF status.current = 0 THEN
|
|
|
+ Log.String("ERROR")
|
|
|
+ ELSE
|
|
|
+ Log.Int(status.current, 0);
|
|
|
+ Log.String(" mA");
|
|
|
+ Log.Ln
|
|
|
+ END;
|
|
|
+ FOR i := 0 TO 5 DO
|
|
|
+ Log.String("Function Group #");
|
|
|
+ Log.Int(i, 0);
|
|
|
+ Log.String(": functions = ");
|
|
|
+ Log.Set(status.functionGroups[i]);
|
|
|
+ Log.String(", status = ");
|
|
|
+ CASE status.functionStatus[i] OF
|
|
|
+ 0: Log.String("switchable")
|
|
|
+ |1: Log.String("switched")
|
|
|
+ |0FH: Log.String("ERROR")
|
|
|
+ END;
|
|
|
+ Log.Ln
|
|
|
+ END
|
|
|
+ END PrintSwitchFuncStatus;
|
|
|
+
|
|
|
+ (** Interrupt handler *)
|
|
|
+ PROCEDURE HandleInterrupt * (hc: HostController);
|
|
|
+ VAR
|
|
|
+ card: Card;
|
|
|
+ result: LONGINT;
|
|
|
+ interruptStatus: SET;
|
|
|
+ BEGIN
|
|
|
+ interruptStatus := hc.regs.InterruptStatus;
|
|
|
+
|
|
|
+ (*IF {Interrupt_Normal_TransferComplete, Interrupt_Normal_ErrorInterrupt} * interruptStatus # {} THEN
|
|
|
+ BEGIN {EXCLUSIVE} continue := TRUE END;
|
|
|
+ RETURN
|
|
|
+ END;*)
|
|
|
+
|
|
|
+ (*!TODO: make interrupt handling as quick as possible - handle all events in SdControllers asynchronously! *)
|
|
|
+ IF Interrupt_Normal_CardInsertion IN interruptStatus THEN
|
|
|
+ hc.regs.InterruptStatus := {Interrupt_Normal_CardInsertion};
|
|
|
+ IF EnableTrace THEN Log.String("[SD] Card Insertion"); Log.Ln END;
|
|
|
+ NEW(card);
|
|
|
+ IF InitCard(hc, card, result) & (hc.handle # NIL) THEN
|
|
|
+ hc.handle(card, OnInitialization, hc.handlerParam)
|
|
|
+ ELSIF EnableTrace THEN
|
|
|
+ Log.String("[SD] Could not initialize card"); Log.Ln
|
|
|
+ END
|
|
|
+ ELSIF Interrupt_Normal_CardRemoval IN interruptStatus THEN
|
|
|
+ hc.regs.InterruptStatus := {Interrupt_Normal_CardRemoval};
|
|
|
+ IF EnableTrace THEN Log.String("[SD] Card Removal"); Log.Ln END;
|
|
|
+ card := hc.cards;
|
|
|
+ IF hc.handle # NIL THEN hc.handle(card, OnRemoval, hc.handlerParam) END;
|
|
|
+ hc.cards := hc.cards.next
|
|
|
+ END;
|
|
|
+ END HandleInterrupt;
|
|
|
+
|
|
|
+(* ==================== Card (High-Level) Interface ==================== *)
|
|
|
+TYPE
|
|
|
+ (** Card descriptor *)
|
|
|
+ Card * = POINTER TO CardDesc;
|
|
|
+ CardDesc * = RECORD
|
|
|
+ state -, (** Card state. Currently not used *)
|
|
|
+ rca -: LONGINT; (** Card RCA *)
|
|
|
+ cid -: Cid; (** CID *)
|
|
|
+ csd -: Csd; (** CSD *)
|
|
|
+ scr -: Scr; (** SCR *)
|
|
|
+ sdStatus -: SdStatus; (** Current SD status for this card *)
|
|
|
+ hc -: HostController; (** Host controller on which the card is attached *)
|
|
|
+ acquire *, release *: PROCEDURE {DELEGATE}; (** Used for synchronization *)
|
|
|
+ readTimeout, (** Read timeout computed for this card, in ms *)
|
|
|
+ writeTimeout, (** Write timeout computed for this card, in ms *)
|
|
|
+ eraseTimeout: LONGINT; (** Erase timeout computed for this card, in ms *)
|
|
|
+ next: Card; (** Internal linked list of cards attached to the same HC *)
|
|
|
+ END;
|
|
|
+
|
|
|
+ (** SD Status *)
|
|
|
+ SdStatus * = RECORD
|
|
|
+ dataBusWidth -: LONGINT; (** Number of DAT bus lines currently used by card *)
|
|
|
+ securedMode -: BOOLEAN; (** Is card in secured mode? *)
|
|
|
+ cardType -: LONGINT; (** Card type, one of Category* *)
|
|
|
+ sizeProtArea -: HUGEINT; (** Size of the protected area, in bytes *)
|
|
|
+ perfMove -: LONGINT; (** Performance of move, in MB/s. 0 means 'sequential write', 255 means 'infinity' *)
|
|
|
+ eraseSize -: LONGINT; (** Numbers of AUs erased at a time. 0 means not supported *)
|
|
|
+ eraseTimeout -: LONGINT; (** Erase timeout value in second, per erase unit. 0 means not supported *)
|
|
|
+ eraseOffset -: LONGINT; (** Fixed timeout for erase timeout, in second *)
|
|
|
+ speedClass -: LONGINT; (** 3.x V speed class: 0 is 'unknown', 2, 4, 6 or 10 *)
|
|
|
+ auSize -: LONGINT; (** AU size for 3.x V *)
|
|
|
+ uhsSpeedGrade -: LONGINT; (** UHS speed grade: 0 is 'not supported', 1 or 3 *)
|
|
|
+ uhsAuSize -: LONGINT; (** AU size in UHS mode *)
|
|
|
+ vscSpeedClass -: LONGINT; (** Video mode speed class: 0 is 'not supported', 6, 10, 30, 60 or 90 *)
|
|
|
+ vscAuSize -: LONGINT; (** AU size in video mode *)
|
|
|
+ suspensionAdr -: LONGINT; (** Current suspension address, in blocks. See CMD20 *)
|
|
|
+ appPerfClass -: LONGINT; (** Application performance class: 0 is 'not supported', 1 or 2 *)
|
|
|
+ perfEnhance -: SET; (** Performance enhancing features of the card. Contains Performance* *)
|
|
|
+ commandQueueDepth -: LONGINT; (** Command queue depth. Valid only if PerformanceCommandQueue IN perfEnhance *)
|
|
|
+ discardSupport -: BOOLEAN; (** Card supports discard? *)
|
|
|
+ fuleSupport -: BOOLEAN; (** card supports FULE? *)
|
|
|
+ END;
|
|
|
+
|
|
|
+ (** Card Identification register *)
|
|
|
+ Cid * = RECORD
|
|
|
+ manufacturingDate -: RECORD (** Manufacturing date, with year and month *)
|
|
|
+ year -,
|
|
|
+ month -: LONGINT
|
|
|
+ END;
|
|
|
+ productSerialNumber -: ADDRESS; (** Serial number *)
|
|
|
+ productRevision -: RECORD (** Revision n.m *)
|
|
|
+ n-, m-: LONGINT
|
|
|
+ END;
|
|
|
+ productName -: ARRAY 6 OF CHAR; (** Product name *)
|
|
|
+ oemId -: ARRAY 3 OF CHAR; (** OEM/Application ID *)
|
|
|
+ manufacturerId -: LONGINT; (** Manufacturer identifier *)
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* Card Registers *)
|
|
|
+ Csd * = RECORD
|
|
|
+ (* Card properties *)
|
|
|
+ capacity -: HUGEINT; (** Card capacity in bytes *)
|
|
|
+ commandClasses -: SET; (** Command classes supported by the card *)
|
|
|
+
|
|
|
+ (* Timing info *)
|
|
|
+ r2w -: LONGINT; (** Read to write time factor = read time / write time *)
|
|
|
+ taac -: REAL; (** Asynchronous access time, in s *)
|
|
|
+ nsac -: LONGINT; (** Worst-case clock dependent access time, in clock cycles *)
|
|
|
+ txSpeed -: LONGINT; (** Max transfer speed in bit/s *)
|
|
|
+
|
|
|
+ (* Block read properties *)
|
|
|
+ partialRead -,
|
|
|
+ misalignedRead -: BOOLEAN;
|
|
|
+ readBlockSize -: LONGINT;
|
|
|
+
|
|
|
+ (* Block write properties *)
|
|
|
+ partialWrite -,
|
|
|
+ misalignedWrite -: BOOLEAN;
|
|
|
+ writeBlockSize -: LONGINT;
|
|
|
+ END;
|
|
|
+
|
|
|
+ (** SCR register *)
|
|
|
+ Scr * = RECORD
|
|
|
+ version -, (** Card physical spec. version: one of Version* *)
|
|
|
+ security -: LONGINT; (** Card security type: one of Type* *)
|
|
|
+ busWidth -: SET; (** Bus widths supported by the card *)
|
|
|
+ commandSupport -: SET; (** Supported commands *)
|
|
|
+ END;
|
|
|
+
|
|
|
+ (**
|
|
|
+ Initializes a new card on the host controller.
|
|
|
+ Executes all commands until either an error occurs or the card is ready for data transfers.
|
|
|
+ *)
|
|
|
+ PROCEDURE InitCard * (hc: HostController; card: Card; VAR result: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ response: LONGINT;
|
|
|
+ status: SET;
|
|
|
+ f8, sdio: BOOLEAN;
|
|
|
+ command: Command;
|
|
|
+ BEGIN
|
|
|
+ SetBusClock(hc, InitialClockFrequency);
|
|
|
+
|
|
|
+ FOR response := 0 TO 10000000 DO END;
|
|
|
+ command.hc := hc;
|
|
|
+
|
|
|
+ (* 1 *)
|
|
|
+ command.command := CMD_GO_IDLE_STATE;
|
|
|
+ command.argument := 0;
|
|
|
+ command.responseType := ResponseNone;
|
|
|
+ command.flags := {};
|
|
|
+ IF ~ExecuteCommand(command, result) THEN RETURN FALSE END;
|
|
|
+ (* 2 *)
|
|
|
+ command.command := CMD_SEND_IF_COND;
|
|
|
+ command.argument := 1AAH;
|
|
|
+ command.responseType := ResponseR7;
|
|
|
+ command.flags := {};
|
|
|
+ IF ~ExecuteCommand(command, result) THEN RETURN FALSE END;
|
|
|
+ (* 3 *)
|
|
|
+ response := GetR7(command);
|
|
|
+ IF response # 1AAH THEN
|
|
|
+ result := ErrorCard;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ f8 := TRUE;
|
|
|
+
|
|
|
+ (* 5 *)
|
|
|
+ command.command := CMD_IO_SEND_OP_COND;
|
|
|
+ command.argument := 0;
|
|
|
+ command.responseType := ResponseR4;
|
|
|
+ command.flags := {};
|
|
|
+ IF ~ExecuteCommand(command, result) & (result = ErrorCmdTimeout) THEN
|
|
|
+ sdio := FALSE;
|
|
|
+ result := ErrorNone;
|
|
|
+ IF ~Reset(hc ,TRUE, FALSE) THEN RETURN FALSE END;
|
|
|
+ ELSIF result # ErrorNone THEN
|
|
|
+ RETURN FALSE
|
|
|
+ ELSE
|
|
|
+ sdio := TRUE;
|
|
|
+ END;
|
|
|
+ IF EnableTrace THEN Log.String("[SD] Card is SDIO: "); Log.Boolean(sdio); Log.Ln END;
|
|
|
+
|
|
|
+ (* 6 *)
|
|
|
+ IF sdio THEN
|
|
|
+ (*! NOT IMPLEMENTED YET *)
|
|
|
+ HALT(100);
|
|
|
+ (* 7 *)
|
|
|
+ (*IF ~StartCommand(hc, CMD_IO_SEND_OP_COND, 800H, ResponseR4, FALSE, FALSE, res) THEN
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+ RETURN TRUE*)
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* A *)
|
|
|
+ (* 12 & 19 *)
|
|
|
+ command.command := ACMD_SD_SEND_OP_COND;
|
|
|
+ command.argument := 0;
|
|
|
+ command.responseType := ResponseR3;
|
|
|
+ command.flags := {FlagApplicationCmd, FlagIgnoreIllegalCmd};
|
|
|
+ IF ~ExecuteCommand(command, result) THEN RETURN FALSE END;
|
|
|
+ response := GetR3(command);
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] VDD: Ranges Supported by Card:"); Log.Ln;
|
|
|
+ IF CardOcr_Vdd27_28 IN SYSTEM.VAL(SET, response) THEN Log.String("[SD] 2.7 - 2.8 V"); Log.Ln END;
|
|
|
+ IF CardOcr_Vdd28_29 IN SYSTEM.VAL(SET, response) THEN Log.String("[SD] 2.8 - 2.9 V"); Log.Ln END;
|
|
|
+ IF CardOcr_Vdd29_30 IN SYSTEM.VAL(SET, response) THEN Log.String("[SD] 2.9 - 3.0 V"); Log.Ln END;
|
|
|
+ IF CardOcr_Vdd30_31 IN SYSTEM.VAL(SET, response) THEN Log.String("[SD] 3.0 - 3.1 V"); Log.Ln END;
|
|
|
+ IF CardOcr_Vdd31_32 IN SYSTEM.VAL(SET, response) THEN Log.String("[SD] 3.1 - 3.2 V"); Log.Ln END;
|
|
|
+ IF CardOcr_Vdd32_33 IN SYSTEM.VAL(SET, response) THEN Log.String("[SD] 3.2 - 3.3 V"); Log.Ln END;
|
|
|
+ IF CardOcr_Vdd33_34 IN SYSTEM.VAL(SET, response) THEN Log.String("[SD] 3.3 - 3.4 V"); Log.Ln END;
|
|
|
+ IF CardOcr_Vdd34_35 IN SYSTEM.VAL(SET, response) THEN Log.String("[SD] 3.4 - 3.5 V"); Log.Ln END;
|
|
|
+ IF CardOcr_Vdd35_36 IN SYSTEM.VAL(SET, response) THEN Log.String("[SD] 3.5 - 3.6 V"); Log.Ln END
|
|
|
+ END;
|
|
|
+
|
|
|
+ status := {30};
|
|
|
+ IF Capabilities_Voltage30 IN hc.regs.Capabilities[0] THEN
|
|
|
+ IF EnableTrace THEN Log.String("[SD] Selecting 3.0 V"); Log.Ln END;
|
|
|
+ INCL(status, CardOcr_Vdd30_31)
|
|
|
+ ELSIF Capabilities_Voltage33 IN hc.regs.Capabilities[0] THEN
|
|
|
+ IF EnableTrace THEN Log.String("[SD] Selecting 3.3 V"); Log.Ln END;
|
|
|
+ INCL(status, CardOcr_Vdd32_33)
|
|
|
+ END;
|
|
|
+
|
|
|
+ command.command := ACMD_SD_SEND_OP_COND;
|
|
|
+ command.argument := SYSTEM.VAL(LONGINT, status);
|
|
|
+ command.responseType := ResponseR3;
|
|
|
+ command.flags := {FlagApplicationCmd, FlagIgnoreIllegalCmd};
|
|
|
+ REPEAT
|
|
|
+ IF ~ExecuteCommand(command, result) THEN RETURN FALSE END;
|
|
|
+ status := SYSTEM.VAL(SET, GetR3(command));
|
|
|
+ UNTIL (CardOcr_PowerUpStatus IN status);
|
|
|
+ IF EnableTrace & (CardOcr_S18A IN status) THEN
|
|
|
+ Log.String("[SD] Card supports 1.8V");
|
|
|
+ Log.Ln
|
|
|
+ END;
|
|
|
+ IF f8 & (CardOcr_CardCapacityStatus IN status) THEN
|
|
|
+ IF EnableTrace THEN Log.String("[SD] Card: SDHC or SDXC") END;
|
|
|
+ card.scr.security := TypeSDHC
|
|
|
+ ELSIF f8 THEN
|
|
|
+ IF EnableTrace THEN Log.String("[SD] Card: SDSC v2 or v3") END;
|
|
|
+ card.scr.security := TypeSDSC
|
|
|
+ ELSE
|
|
|
+ IF EnableTrace THEN Log.String("[SD] Card: SDSC v1.0 or v1.1") END;
|
|
|
+ card.scr.security := TypeSDSC
|
|
|
+ END;
|
|
|
+ IF EnableTrace THEN Log.Ln END;
|
|
|
+
|
|
|
+ (* 32 *)
|
|
|
+ command.command := CMD_ALL_SEND_CID;
|
|
|
+ command.argument := 0;
|
|
|
+ command.responseType := ResponseR2;
|
|
|
+ command.flags := {};
|
|
|
+ IF ~ExecuteCommand(command, result) THEN RETURN FALSE END;
|
|
|
+ DecodeCid(command.response, card.cid);
|
|
|
+ PrintCardCid(card.cid);
|
|
|
+
|
|
|
+ (* 33 *)
|
|
|
+ command.command := CMD_SEND_RELATIVE_ADDR;
|
|
|
+ command.argument := 0;
|
|
|
+ command.responseType := ResponseR6;
|
|
|
+ command.flags := {};
|
|
|
+ REPEAT
|
|
|
+ IF ~ExecuteCommand(command, result) THEN RETURN FALSE END;
|
|
|
+ card.rca := LSH(GetR6(command), -16)
|
|
|
+ UNTIL card.rca # 0;
|
|
|
+ IF EnableTrace THEN Log.String("[SD] New Card with RCA: "); Log.Hex(card.rca, -4); Log.Ln END;
|
|
|
+ status := SYSTEM.VAL(SET, GetR6(command));
|
|
|
+ status := status * {0 .. 15};
|
|
|
+ (* status is a modified CardStatus: reform corresponding card status *)
|
|
|
+ IF 15 IN status THEN EXCL(status, 15); INCL(status, 23) END;
|
|
|
+ IF 14 IN status THEN EXCL(status, 14); INCL(status, 22) END;
|
|
|
+ IF 13 IN status THEN EXCL(status, 13); INCL(status, 19) END;
|
|
|
+ IF EnableTrace THEN PrintCardStatus(status) END;
|
|
|
+ card.hc := hc;
|
|
|
+ card.next := hc.cards;
|
|
|
+ hc.cards := card;
|
|
|
+ IF Synchronize THEN SdEnvironment.GetLock(card.acquire, card.release) END;
|
|
|
+
|
|
|
+ (* Get Additional card registers: CSD *)
|
|
|
+ IF ~ReadCsd(card, result) THEN RETURN FALSE END;
|
|
|
+
|
|
|
+ SetBusClock(hc, card.csd.txSpeed);
|
|
|
+ (* Reasonable default timeout values, later rewritten with the ones given by the card *)
|
|
|
+ card.readTimeout := 100;
|
|
|
+ card.writeTimeout := 250;
|
|
|
+ card.eraseTimeout := 250;
|
|
|
+
|
|
|
+ (*IF ~Reset(hc, TRUE, FALSE) OR ~Reset(hc, FALSE, TRUE) THEN RETURN FALSE END;*)
|
|
|
+ IF ~ReadScr(card, result) THEN RETURN FALSE END;
|
|
|
+ ComputeTimeouts(card);
|
|
|
+
|
|
|
+ IF (card.scr.version >= Version1p1) THEN
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] Enabling high-speed mode");
|
|
|
+ Log.Ln
|
|
|
+ END;
|
|
|
+ IF ~SelectSpeedMode(card, TRUE, result) THEN RETURN FALSE END;
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] High-speed mode enabled");
|
|
|
+ Log.Ln
|
|
|
+ END;
|
|
|
+
|
|
|
+ (* Get CSD again: transfer speed might have changed *)
|
|
|
+ IF ~ReadCsd(card, result) THEN RETURN FALSE END;
|
|
|
+ ComputeTimeouts(card);
|
|
|
+ SetBusClock(hc, card.csd.txSpeed)
|
|
|
+ END;
|
|
|
+
|
|
|
+ IF 4 IN card.scr.busWidth THEN
|
|
|
+
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] Changing bus width to 4 bits");
|
|
|
+ Log.Ln
|
|
|
+ END;
|
|
|
+
|
|
|
+ IF ~SetBusWidth(card.hc, card, 4, result) THEN RETURN FALSE END;
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] Bus width changed");
|
|
|
+ Log.Ln
|
|
|
+ END
|
|
|
+ END;
|
|
|
+ IF ~Reset(hc, TRUE, FALSE) OR ~Reset(hc, FALSE, TRUE) THEN RETURN FALSE END;
|
|
|
+ GetSdStatus(card);
|
|
|
+
|
|
|
+ (*ResetStatistics; NEW(testbuf);
|
|
|
+ FOR response := 1 TO 100 DO
|
|
|
+ IF ~Read(card, 33554432, LEN(testbuf), testbuf^, 0, result) THEN RETURN FALSE END;
|
|
|
+ IF ~Write(card, 33554432, LEN(testbuf), testbuf^, 0, result) THEN RETURN FALSE END;
|
|
|
+ END;
|
|
|
+ Statistics(Commands.GetContext());
|
|
|
+ HALT(512);*)
|
|
|
+ RETURN TRUE
|
|
|
+ END InitCard;
|
|
|
+
|
|
|
+ (** Write 'data[ofs, ofs + len)' to 'card', starting at block 'firstBlock'. *)
|
|
|
+ PROCEDURE Write * (card: Card; firstBlock, len: LONGINT; VAR data: ARRAY OF SYSTEM.BYTE; ofs: LONGINT; VAR result: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ command: Command;
|
|
|
+ start, stop: HUGEINT;
|
|
|
+ ret: BOOLEAN;
|
|
|
+ BEGIN
|
|
|
+ result := ErrorNone;
|
|
|
+ IF Synchronize THEN card.acquire END;
|
|
|
+ start := SdEnvironment.GetTimeCounter();
|
|
|
+ IF ~SelectCard(card.hc, card.rca, result) THEN
|
|
|
+ IF Synchronize THEN card.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+
|
|
|
+ command.hc := card.hc;
|
|
|
+ command.rca := card.rca;
|
|
|
+
|
|
|
+ (* Pre-erase blocks *)
|
|
|
+ command.command := ACMD_SET_WR_BLK_ERASE_COUNT;
|
|
|
+ command.flags := {FlagApplicationCmd};
|
|
|
+ command.responseType := ResponseR1;
|
|
|
+ command.argument := (len + BlockSize - 1) DIV BlockSize;
|
|
|
+ IF ~ExecuteCommand(command, result) THEN
|
|
|
+ IF Synchronize THEN card.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+
|
|
|
+ command.argument := firstBlock;
|
|
|
+ command.responseType := ResponseR1;
|
|
|
+ command.flags := {FlagData};
|
|
|
+ command.dataTimeout := card.writeTimeout;
|
|
|
+ command.blockSize := card.csd.writeBlockSize;
|
|
|
+ IF len > card.csd.writeBlockSize THEN
|
|
|
+ INCL(command.flags, FlagMultipleBlockTx);
|
|
|
+ INCL(command.flags, FlagCountBlocks);
|
|
|
+ INCL(command.flags, FlagAutoCmd12);
|
|
|
+ command.command := CMD_WRITE_MULTIPLE_BLOCK;
|
|
|
+ ELSE
|
|
|
+ command.command := CMD_WRITE_BLOCK
|
|
|
+ END;
|
|
|
+ ret := command.hc.transfer(command, data, ofs, len, result);
|
|
|
+ stop := SdEnvironment.GetTimeCounter();
|
|
|
+ IF Synchronize THEN card.release END;
|
|
|
+ IF ret THEN
|
|
|
+ INC(Nwrite);
|
|
|
+ INC(NbyteWritten, len);
|
|
|
+ INC(Twrite, stop - start)
|
|
|
+ END;
|
|
|
+ RETURN ret
|
|
|
+ END Write;
|
|
|
+
|
|
|
+ (** Read 'len' bytes starting from 'firstBlock' of 'card' to 'data[ofs, ofs + len)' *)
|
|
|
+ PROCEDURE Read * (card: Card; firstBlock, len: LONGINT; VAR data: ARRAY OF SYSTEM.BYTE; ofs: LONGINT; VAR result: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ command: Command;
|
|
|
+ start, stop: HUGEINT;
|
|
|
+ ret: BOOLEAN;
|
|
|
+ BEGIN
|
|
|
+ IF Synchronize THEN card.acquire END;
|
|
|
+ start := SdEnvironment.GetTimeCounter();
|
|
|
+ IF ~SelectCard(card.hc, card.rca, result) THEN
|
|
|
+ IF Synchronize THEN card.release END;
|
|
|
+ RETURN FALSE
|
|
|
+ END;
|
|
|
+
|
|
|
+ command.hc := card.hc;
|
|
|
+ command.argument := firstBlock;
|
|
|
+ command.responseType := ResponseR1;
|
|
|
+ (*command.flags := {FlagData, FlagRead};*)
|
|
|
+ command.rca := card.rca;
|
|
|
+ command.dataTimeout := card.readTimeout;
|
|
|
+ command.blockSize := card.csd.readBlockSize;
|
|
|
+ IF len > card.csd.readBlockSize THEN
|
|
|
+ command.flags := {FlagData, FlagRead, FlagMultipleBlockTx, FlagCountBlocks, FlagAutoCmd12};
|
|
|
+ (*INCL(command.flags, FlagMultipleBlockTx);
|
|
|
+ INCL(command.flags, FlagCountBlocks);
|
|
|
+ INCL(command.flags, FlagAutoCmd12);*)
|
|
|
+ command.command := CMD_READ_MULTIPLE_BLOCK
|
|
|
+ ELSE
|
|
|
+ command.flags := {FlagData, FlagRead};
|
|
|
+ command.command := CMD_READ_SINGLE_BLOCK
|
|
|
+ END;
|
|
|
+ ret := command.hc.transfer(command, data, ofs, len, result) & ~(CardStatus_Error IN GetR1(command));
|
|
|
+ stop := SdEnvironment.GetTimeCounter();
|
|
|
+ IF Synchronize THEN card.release END;
|
|
|
+ IF ret THEN
|
|
|
+ INC(Nread);
|
|
|
+ INC(NbyteRead, len);
|
|
|
+ INC(Tread, stop - start)
|
|
|
+ END;
|
|
|
+ RETURN ret
|
|
|
+ END Read;
|
|
|
+
|
|
|
+ (** Erase blocks [block, block + num) on specified card. *)
|
|
|
+ PROCEDURE Erase * (card: Card; block, num: LONGINT; VAR result: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ command: Command;
|
|
|
+ r1: SET;
|
|
|
+ BEGIN
|
|
|
+ command.hc := card.hc;
|
|
|
+ command.flags := {};
|
|
|
+ command.rca := card.rca;
|
|
|
+ command.dataTimeout := card.eraseTimeout;
|
|
|
+
|
|
|
+ command.responseType := ResponseR1;
|
|
|
+ command.argument := block;
|
|
|
+ command.command := CMD_ERASE_WR_BLK_START;
|
|
|
+ IF ~ExecuteCommand(command, result) & (CardStatus_Error IN GetR1(command)) THEN RETURN FALSE END;
|
|
|
+
|
|
|
+ command.argument := block + num - 1;
|
|
|
+ command.command := CMD_ERASE_WR_BLK_END;
|
|
|
+ IF ~ExecuteCommand(command, result) & (CardStatus_Error IN GetR1(command)) THEN RETURN FALSE END;
|
|
|
+
|
|
|
+ command.argument := 0;
|
|
|
+ command.command := CMD_ERASE;
|
|
|
+ command.responseType := ResponseR1b;
|
|
|
+ IF ~ExecuteCommand(command, result) & (CardStatus_Error IN GetR1(command)) THEN RETURN FALSE END;
|
|
|
+
|
|
|
+ (*WHILE 20 IN card.hc.regs.PresentState DO END;*)
|
|
|
+ command.command := CMD_SEND_STATUS;
|
|
|
+ command.responseType := ResponseR1;
|
|
|
+ REPEAT
|
|
|
+ IF ~ExecuteCommand(command, result) THEN RETURN FALSE END;
|
|
|
+ r1 := GetR1(command);
|
|
|
+ IF CardStatus_Error IN r1 THEN RETURN FALSE END
|
|
|
+ UNTIL CardStatus_ReadyForData IN r1;
|
|
|
+ RETURN TRUE
|
|
|
+ END Erase;
|
|
|
+
|
|
|
+ PROCEDURE ReadCsd (card: Card; VAR result: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ command: Command;
|
|
|
+ csd: ARRAY 4 OF LONGINT;
|
|
|
+ BEGIN
|
|
|
+ result := ErrorNone;
|
|
|
+ IF ~DeselectCards(card.hc, result) THEN RETURN FALSE END;
|
|
|
+
|
|
|
+ command.hc := card.hc;
|
|
|
+ command.command := CMD_SEND_CSD;
|
|
|
+ command.argument := LSH(card.rca, 16);
|
|
|
+ command.responseType := ResponseR2;
|
|
|
+ command.flags := {};
|
|
|
+ IF ~ExecuteCommand(command, result) THEN RETURN FALSE END;
|
|
|
+ GetR2(command, csd);
|
|
|
+ DecodeCsd(csd, card.csd);
|
|
|
+ IF EnableTrace THEN
|
|
|
+ PrintCardCsd(csd);
|
|
|
+ Log.String("[SD] Card Capacity: ");
|
|
|
+ PrintSize(card.csd.capacity);
|
|
|
+ Log.Ln;
|
|
|
+ Log.String("[SD] Bus frequency: "); Log.Int(card.csd.txSpeed, 0); Log.String(" Hz"); Log.Ln
|
|
|
+ END;
|
|
|
+ RETURN TRUE
|
|
|
+ END ReadCsd;
|
|
|
+
|
|
|
+ (** Read the SD card Configuration Register of a card *)
|
|
|
+ PROCEDURE ReadScr (card: Card; VAR result: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ command: Command;
|
|
|
+ ofs: LONGINT;
|
|
|
+ scr: ARRAY 8 OF CHAR;
|
|
|
+ BEGIN
|
|
|
+ IF ~SelectCard(card.hc, card.rca, result) THEN RETURN FALSE END;
|
|
|
+
|
|
|
+ (*
|
|
|
+ disconnect the pull-up resistor on D3 line (important for high-speed mode with 4 lines)
|
|
|
+ *)
|
|
|
+ (*command.hc := card.hc;
|
|
|
+ command.command := ACMD_SET_CLR_CARD_DETECT;
|
|
|
+ command.argument := 0;
|
|
|
+ command.responseType := ResponseR1;
|
|
|
+ command.flags := {FlagApplicationCmd};
|
|
|
+ command.rca := card.rca;
|
|
|
+ IF ~ExecuteCommand(command, result) THEN RETURN FALSE END;*)
|
|
|
+
|
|
|
+ (* Get Card Register: SCR *)
|
|
|
+ command.hc := card.hc;
|
|
|
+ command.command := ACMD_SEND_SCR;
|
|
|
+ command.argument := 0;
|
|
|
+ command.responseType := ResponseR1;
|
|
|
+ command.flags := {FlagApplicationCmd, FlagData, FlagRead};
|
|
|
+ command.rca := card.rca;
|
|
|
+ command.dataTimeout := card.readTimeout;
|
|
|
+ (*ofs := 32 - ADDRESSOF(scr[0]) MOD 32;*)
|
|
|
+ IF ~card.hc.transfer(command, scr, ofs, 8, result) THEN RETURN FALSE END;
|
|
|
+ IF CardStatus_Error IN GetR1(command) THEN result := ErrorCard; RETURN FALSE END;
|
|
|
+ DecodeScr(scr, ofs, card.scr);
|
|
|
+ IF EnableTrace THEN PrintCardScr(card.scr) END;
|
|
|
+ RETURN TRUE
|
|
|
+ END ReadScr;
|
|
|
+
|
|
|
+ PROCEDURE GetSdStatus (card: Card);
|
|
|
+ TYPE Bitfield = ARRAY 16 OF LONGINT;
|
|
|
+ VAR
|
|
|
+ status: ARRAY 64 OF CHAR;
|
|
|
+ command: Command;
|
|
|
+ ignore: LONGINT;
|
|
|
+ bitfield: POINTER {UNSAFE,UNTRACED} TO Bitfield;
|
|
|
+ c: CHAR;
|
|
|
+ i: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ ASSERT(SelectCard(card.hc, card.rca, ignore));
|
|
|
+ command.hc := card.hc;
|
|
|
+ command.rca := card.rca;
|
|
|
+ command.command := ACMD_SD_STATUS;
|
|
|
+ command.flags := {FlagApplicationCmd, FlagData, FlagRead};
|
|
|
+ command.responseType := ResponseR1;
|
|
|
+ command.dataTimeout := card.readTimeout;
|
|
|
+ IF ~card.hc.transfer(command, status, 0, LEN(status), ignore) THEN RETURN END;
|
|
|
+
|
|
|
+ FOR i := 0 TO LEN(status) DIV 2 DO
|
|
|
+ c := status[i];
|
|
|
+ status[i] := status[LEN(status) - 1 - i];
|
|
|
+ status[LEN(status) - 1 - i] := c
|
|
|
+ END;
|
|
|
+
|
|
|
+ bitfield := ADDRESSOF(status[0]);
|
|
|
+ DecodeSdStatus(bitfield^, card.sdStatus);
|
|
|
+ PrintSdStatus(card.sdStatus);
|
|
|
+ END GetSdStatus;
|
|
|
+
|
|
|
+ PROCEDURE GetCid (card: Card);
|
|
|
+ VAR
|
|
|
+ cid: Cid;
|
|
|
+ command: Command;
|
|
|
+ res: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ IF ~DeselectCards(card.hc, res) THEN HALT(512) END;
|
|
|
+ command.hc := card.hc;
|
|
|
+ command.command := CMD_SEND_CID;
|
|
|
+ command.argument := LSH(card.rca, 16);
|
|
|
+ command.flags := {};
|
|
|
+ command.responseType := ResponseR2;
|
|
|
+ IF ~ExecuteCommand(command, res) THEN HALT(512) END;
|
|
|
+ DecodeCid(command.response, cid);
|
|
|
+ PrintCardCid(cid)
|
|
|
+ END GetCid;
|
|
|
+
|
|
|
+ (**
|
|
|
+ Computes data timeouts for read, write and erase operations according to SD specifications.
|
|
|
+ Stores them in card.readTimeout, writeTimeout, eraseTimeout.
|
|
|
+ *)
|
|
|
+ PROCEDURE ComputeTimeouts (card: Card);
|
|
|
+ VAR
|
|
|
+ readTime: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ (*
|
|
|
+ Read timeout is the lower of:
|
|
|
+ o (CSD.TAAC + CSD.NSAC / busfreq * 100) * TimeoutReadFactor
|
|
|
+ o TimeoutReadFix
|
|
|
+ for a normal SD card and
|
|
|
+ TimeoutReadFix
|
|
|
+ for a SDHC card.
|
|
|
+
|
|
|
+ Write timeout is very similar to read timeout, except that (CSD.TAAC + CSD.NSAC) * CSD.R2W is used.
|
|
|
+ *)
|
|
|
+ IF card.scr.version >= TypeSDHC THEN
|
|
|
+ card.readTimeout := TimeoutReadFix;
|
|
|
+ card.writeTimeout := TimeoutWriteFix
|
|
|
+ ELSE
|
|
|
+ readTime := 100 * LONGINT((card.csd.taac + REAL(card.csd.nsac * 100) / REAL(card.hc.frequency)) * 1000.0);
|
|
|
+ card.readTimeout := MIN(readTime, TimeoutReadFix);
|
|
|
+ card.writeTimeout := MIN(readTime * card.csd.r2w, TimeoutWriteFix);
|
|
|
+ END;
|
|
|
+ card.eraseTimeout := TimeoutErase;
|
|
|
+
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] Read timeout = "); Log.Int(card.readTimeout, 0); Log.String(" ms"); Log.Ln;
|
|
|
+ Log.String("[SD] Write timeout = "); Log.Int(card.writeTimeout, 0); Log.String(" ms"); Log.Ln;
|
|
|
+ Log.String("[SD] Erase timeout = "); Log.Int(card.eraseTimeout, 0); Log.String(" ms"); Log.Ln
|
|
|
+ END
|
|
|
+ END ComputeTimeouts;
|
|
|
+
|
|
|
+ (** Select card speed mode. It is necessary to set it to high in order to use higher bus clock frequencies. *)
|
|
|
+ PROCEDURE SelectSpeedMode(card: Card; high: BOOLEAN; VAR res: LONGINT): BOOLEAN;
|
|
|
+ VAR
|
|
|
+ funcs: ARRAY 6 OF LONGINT;
|
|
|
+ status: SwitchFuncStatus;
|
|
|
+ val: SET;
|
|
|
+ BEGIN
|
|
|
+ funcs[0] := 1;
|
|
|
+ IF ~SwitchFunc(card, FALSE, funcs, status, res) THEN RETURN FALSE END;
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] Select speed, before:");
|
|
|
+ Log.Ln;
|
|
|
+ PrintSwitchFuncStatus(status)
|
|
|
+ END;
|
|
|
+ IF ~(1 IN status.functionGroups[0]) THEN
|
|
|
+ Log.String("[SD] HIGH-SPEED MODE NOT SUPPORTED");
|
|
|
+ Log.Ln;
|
|
|
+ RETURN TRUE
|
|
|
+ END;
|
|
|
+ IF ~SwitchFunc(card, TRUE, funcs, status, res) THEN RETURN FALSE END;
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] Select speed, after:");
|
|
|
+ Log.Ln;
|
|
|
+ PrintSwitchFuncStatus(status)
|
|
|
+ END;
|
|
|
+ val := SYSTEM.VAL(SET, LONGINT(card.hc.regs.HostControl1));
|
|
|
+ IF high THEN
|
|
|
+ INCL(val, HostControl1_HighSpeedEnable)
|
|
|
+ ELSE
|
|
|
+ EXCL(val, HostControl1_HighSpeedEnable)
|
|
|
+ END;
|
|
|
+ card.hc.regs.HostControl1 := SYSTEM.VAL(SHORTINT, val);
|
|
|
+ RETURN TRUE
|
|
|
+ END SelectSpeedMode;
|
|
|
+
|
|
|
+ PROCEDURE DecodeSdStatus (CONST raw: ARRAY OF LONGINT; VAR status: SdStatus);
|
|
|
+ VAR
|
|
|
+ val: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ val := ReadBitfield(raw, SdStatus_DatBusWidthOfs, SdStatus_DatBusWidthWidth);
|
|
|
+ CASE val OF
|
|
|
+ 0: status.dataBusWidth := 1
|
|
|
+ |2: status.dataBusWidth := 4
|
|
|
+ ELSE
|
|
|
+ status.dataBusWidth := 0
|
|
|
+ END;
|
|
|
+ status.securedMode := ReadBit(raw, SdStatus_SecuredMode);
|
|
|
+ val := ReadBitfield(raw, SdStatus_SdCardTypeOfs, SdStatus_SdCardTypeWidth);
|
|
|
+ CASE val OF
|
|
|
+ 0: status.cardType := CategoryRW
|
|
|
+ |1: status.cardType := CategoryRO
|
|
|
+ |2: status.cardType := CategoryOTP
|
|
|
+ END;
|
|
|
+ status.sizeProtArea := ReadBitfield(raw, SdStatus_SizeOfProtectedAreaOfs, SdStatus_SizeOfProtectedAreaWidth);
|
|
|
+ (*! TODO: multiply sizeProtArea by MULT * BLOCK_LEN if SDSC *)
|
|
|
+ val := ReadBitfield(raw, SdStatus_SpeedClassOfs, SdStatus_SpeedClassWidth);
|
|
|
+ CASE val OF
|
|
|
+ 0 .. 3: status.speedClass := 2 * val
|
|
|
+ |4: status.speedClass := 10
|
|
|
+ END;
|
|
|
+ status.perfMove := ReadBitfield(raw, SdStatus_PerformanceMoveOfs, SdStatus_PerformanceMoveWidth);
|
|
|
+ status.auSize := ReadBitfield(raw, SdStatus_AuSizeOfs, SdStatus_AuSizeWidth) * 16 * 1024;
|
|
|
+ status.eraseSize := ReadBitfield(raw, SdStatus_EraseSizeOfs, SdStatus_EraseSizeWidth);
|
|
|
+ status.eraseTimeout := ReadBitfield(raw, SdStatus_EraseTimeoutOfs, SdStatus_EraseTimeoutWidth);
|
|
|
+ status.eraseOffset := ReadBitfield(raw, SdStatus_EraseOffsetOfs, SdStatus_EraseOffsetWidth);
|
|
|
+ val := ReadBitfield(raw, SdStatus_UhsSpeedGradeOfs, SdStatus_UhsSpeedGradeWidth);
|
|
|
+ CASE val OF
|
|
|
+ 0, 1, 3: status.uhsSpeedGrade := val
|
|
|
+ END;
|
|
|
+ status.uhsAuSize := ReadBitfield(raw, SdStatus_UhsAuSizeOfs, SdStatus_UhsAuSizeWidth) * 1024 * 1024;
|
|
|
+ status.vscSpeedClass := ReadBitfield(raw, SdStatus_VideoSpeedClassOfs, SdStatus_VideoSpeedClassWidth);
|
|
|
+ status.vscAuSize := ReadBitfield(raw, SdStatus_VscAuSizeOfs, SdStatus_VscAuSizeWidth) * 1024 * 1024;
|
|
|
+ status.suspensionAdr := ReadBitfield(raw, SdStatus_SusAddrOfs, SdStatus_SusAddrWidth);
|
|
|
+ status.appPerfClass := ReadBitfield(raw, SdStatus_AppPerfClassOfs, SdStatus_AppPerfClassWidth);
|
|
|
+ val := ReadBitfield(raw, SdStatus_PerformanceEnhanceOfs, SdStatus_PerformanceEnhanceWidth);
|
|
|
+ status.perfEnhance := SYSTEM.VAL(SET, val) * {PerformanceCardMaintenance .. PerformanceCache};
|
|
|
+ IF SYSTEM.VAL(SET, val) * {3 .. MAX(SET)} # {} THEN
|
|
|
+ INCL(status.perfEnhance, PerformanceQueue);
|
|
|
+ status.commandQueueDepth := LSH(val, -3) + 1
|
|
|
+ END;
|
|
|
+ status.discardSupport := ReadBit(raw, SdStatus_DiscardSupport);
|
|
|
+ status.fuleSupport := ReadBit(raw, SdStatus_FuleSupport)
|
|
|
+ END DecodeSdStatus;
|
|
|
+
|
|
|
+ PROCEDURE DecodeCid (CONST raw: ARRAY OF LONGINT; VAR cid: Cid);
|
|
|
+ VAR
|
|
|
+ val: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ val := ReadBitfield(raw, CardCid_ProductManufacturingDateOfs, CardCid_ProductManufacturingDateWidth);
|
|
|
+ cid.manufacturingDate.year := val DIV 10H + 2000;
|
|
|
+ cid.manufacturingDate.month := val MOD 10H;
|
|
|
+ cid.productSerialNumber := SYSTEM.VAL(ADDRESS, ReadBitfield(raw, CardCid_ProductSerialNbOfs, CardCid_ProductSerialNbWidth));
|
|
|
+ val := ReadBitfield(raw, CardCid_ProductRevisionOfs, CardCid_ProductRevisionWidth);
|
|
|
+ cid.productRevision.n := val DIV 10H;
|
|
|
+ cid.productRevision.m := val MOD 10H;
|
|
|
+ SYSTEM.MOVE(ADDRESSOF(raw[0]) + CardCid_ProductNameOfs DIV 8, ADDRESSOF(cid.productName), CardCid_ProductNameWidth DIV 8);
|
|
|
+ SYSTEM.MOVE(ADDRESSOF(raw[0]) + CardCid_OEM_ApplicationIdOfs DIV 8, ADDRESSOF(cid.oemId), CardCid_OEM_ApplicationIdWidth DIV 8);
|
|
|
+ cid.manufacturerId := ReadBitfield(raw, CardCid_ManufacturerIdOfs, CardCid_ManufacturerIdWidth)
|
|
|
+ END DecodeCid;
|
|
|
+
|
|
|
+ (** Fills a Csd record from the raw csd bytes *)
|
|
|
+ PROCEDURE DecodeCsd (CONST raw: ARRAY OF LONGINT; VAR csd: Csd);
|
|
|
+ VAR
|
|
|
+ sizeMult, val, version: LONGINT;
|
|
|
+ real: REAL;
|
|
|
+ BEGIN
|
|
|
+ version := ReadBitfield(raw, CardCsd_CsdStructureOfs, CardCsd_CsdStructureWidth) + 1;
|
|
|
+
|
|
|
+ IF version = 1 THEN
|
|
|
+ sizeMult := LSH(LONGINT(2), ReadBitfield(raw, CardCsd_CSizeMultOfs1, CardCsd_CSizeMultWidth1));
|
|
|
+ csd.capacity := sizeMult * (1 + ReadBitfield(raw, CardCsd_CSizeOfs1, CardCsd_CSizeWidth1)) * 512;
|
|
|
+ ELSE
|
|
|
+ csd.capacity := 512 * 1024 * (HUGEINT(ReadBitfield(raw, CardCsd_CSizeOfs2, CardCsd_CSizeWidth2)) + 1);
|
|
|
+ END;
|
|
|
+
|
|
|
+ csd.commandClasses := SYSTEM.VAL(SET, ReadBitfield(raw, CardCsd_CccOfs, CardCsd_CccWidth));
|
|
|
+ csd.nsac := ReadBitfield(raw, CardCsd_NsacOfs, CardCsd_NsacWidth) * 100;
|
|
|
+
|
|
|
+ val := ReadBitfield(raw, CardCsd_R2wFactorOfs, CardCsd_R2wFactorWidth);
|
|
|
+ IF val >= 6 THEN
|
|
|
+ csd.r2w := 0
|
|
|
+ ELSE
|
|
|
+ csd.r2w := LSH(LONGINT(1), val);
|
|
|
+ END;
|
|
|
+
|
|
|
+ val := ReadBitfield(raw, CardCsd_TranSpeedOfs, CardCsd_TranSpeedWidth);
|
|
|
+ CASE val DIV 8 OF
|
|
|
+ 1: csd.txSpeed := 10
|
|
|
+ |2: csd.txSpeed := 12
|
|
|
+ |3: csd.txSpeed := 13
|
|
|
+ |4: csd.txSpeed := 15
|
|
|
+ |5: csd.txSpeed := 20
|
|
|
+ |6: csd.txSpeed := 25
|
|
|
+ |7: csd.txSpeed := 30
|
|
|
+ |8: csd.txSpeed := 35
|
|
|
+ |9: csd.txSpeed := 40
|
|
|
+ |10: csd.txSpeed := 45
|
|
|
+ |11: csd.txSpeed := 50
|
|
|
+ |12: csd.txSpeed := 55
|
|
|
+ |13: csd.txSpeed := 60
|
|
|
+ |14: csd.txSpeed := 70
|
|
|
+ |15: csd.txSpeed := 80
|
|
|
+ ELSE
|
|
|
+ csd.txSpeed := 00
|
|
|
+ END;
|
|
|
+ csd.txSpeed := csd.txSpeed * 100;
|
|
|
+ CASE val MOD 8 OF
|
|
|
+ 0: csd.txSpeed := csd.txSpeed * 100
|
|
|
+ |1: csd.txSpeed := csd.txSpeed * 1000
|
|
|
+ |2: csd.txSpeed := csd.txSpeed * 10000
|
|
|
+ |3: csd.txSpeed := csd.txSpeed * 100000
|
|
|
+ END;
|
|
|
+
|
|
|
+ val := ReadBitfield(raw, CardCsd_TaacOfs, CardCsd_TaacWidth);
|
|
|
+ CASE val DIV 8 OF
|
|
|
+ 1: real := 1.0
|
|
|
+ |2: real := 1.2
|
|
|
+ |3: real := 1.3
|
|
|
+ |4: real := 1.5
|
|
|
+ |5: real := 2.0
|
|
|
+ |6: real := 2.5
|
|
|
+ |7: real := 3.0
|
|
|
+ |8: real := 3.5
|
|
|
+ |9: real := 4.0
|
|
|
+ |10: real := 4.5
|
|
|
+ |11: real := 5.0
|
|
|
+ |12: real := 5.5
|
|
|
+ |13: real := 6.0
|
|
|
+ |14: real := 7.0
|
|
|
+ |15: real := 8.0
|
|
|
+ ELSE
|
|
|
+ real := 0.0
|
|
|
+ END;
|
|
|
+ CASE val MOD 8 OF
|
|
|
+ 0: real := real * 1.0E-9
|
|
|
+ |1: real := real * 1.0E-8
|
|
|
+ |2: real := real * 1.0E-7
|
|
|
+ |3: real := real * 1.0E-6
|
|
|
+ |4: real := real * 1.0E-5
|
|
|
+ |5: real := real * 1.0E-4
|
|
|
+ |6: real := real * 1.0E-3
|
|
|
+ |7: real := real * 1.0E-2
|
|
|
+ END;
|
|
|
+ csd.taac := real;
|
|
|
+
|
|
|
+ csd.partialRead := ReadBitfield(raw, CardCsd_ReadBlPartial, 1) = 1;
|
|
|
+ csd.misalignedRead := ReadBitfield(raw, CardCsd_ReadBlkMisalign, 1) = 1;
|
|
|
+ val := ReadBitfield(raw, CardCsd_ReadBlLenOfs, CardCsd_ReadBlLenWidth);
|
|
|
+ IF (val <= 8) OR (val >= 12) THEN
|
|
|
+ csd.readBlockSize := BlockSize
|
|
|
+ ELSE
|
|
|
+ csd.readBlockSize := LSH(LONGINT(1), val)
|
|
|
+ END;
|
|
|
+
|
|
|
+ csd.partialWrite := ReadBitfield(raw, CardCsd_WriteBlPartial, 1) = 1;
|
|
|
+ csd.misalignedWrite := ReadBitfield(raw, CardCsd_WriteBlkMisalign, 1) = 1;
|
|
|
+ val := ReadBitfield(raw, CardCsd_WriteBlLenOfs, CardCsd_WriteBlLenWidth);
|
|
|
+ IF (val <= 8) OR (val >= 12) THEN
|
|
|
+ csd.writeBlockSize := BlockSize
|
|
|
+ ELSE
|
|
|
+ csd.writeBlockSize := LSH(LONGINT(1), val)
|
|
|
+ END
|
|
|
+ END DecodeCsd;
|
|
|
+
|
|
|
+ (** Fills a SCR record from raw data bytes *)
|
|
|
+ PROCEDURE DecodeScr (CONST raw: ARRAY OF CHAR; ofs: LONGINT; VAR scr: Scr);
|
|
|
+ TYPE
|
|
|
+ Array = ARRAY 8 OF CHAR;
|
|
|
+ VAR
|
|
|
+ bfield: ARRAY 2 OF LONGINT;
|
|
|
+ i: LONGINT;
|
|
|
+ val: SET;
|
|
|
+ BEGIN
|
|
|
+ FOR i := 0 TO 7 DO SYSTEM.VAL(Array, bfield)[7-i] := raw[ofs + i] END;
|
|
|
+ IF ReadBitfield(bfield, CardScr_StructureOfs, CardScr_StructureWidth) # 0 THEN RETURN END;
|
|
|
+ scr.version := ReadBitfield(bfield, CardScr_SpecVersionOfs, CardScr_SpecVersionWidth);
|
|
|
+ IF ReadBitfield(bfield, CardScr_SpecV3, 1) # 0 THEN scr.version := Version3 END;
|
|
|
+ IF ReadBitfield(bfield, CardScr_SpecV4, 1) # 0 THEN scr.version := Version4 END;
|
|
|
+ i := ReadBitfield(bfield, CardScr_SpecVXOfs, CardScr_SpecVXWidth);
|
|
|
+ IF i = CardScr_SpecVX_v5 THEN scr.version := Version5
|
|
|
+ ELSIF i = CardScr_SpecVX_v6 THEN scr.version := Version6
|
|
|
+ END;
|
|
|
+
|
|
|
+ CASE ReadBitfield(bfield, CardScr_SecurityOfs, CardScr_SecurityWidth) OF
|
|
|
+ 0: scr.security := TypeNone
|
|
|
+ |2: scr.security := TypeSDSC
|
|
|
+ |3: scr.security := TypeSDHC
|
|
|
+ |4: scr.security := TypeSDXC
|
|
|
+ END;
|
|
|
+ val := SYSTEM.VAL(SET, ReadBitfield(bfield, CardScr_BusWidthsOfs, CardScr_BusWidthsWidth));
|
|
|
+ FOR i := 0 TO MAX(SET) - 1 DO
|
|
|
+ IF i IN val THEN
|
|
|
+ INCL(scr.busWidth, LSH(LONGINT(1), i))
|
|
|
+ END
|
|
|
+ END
|
|
|
+ END DecodeScr;
|
|
|
+
|
|
|
+ (**
|
|
|
+ Print the state of all Host Controller registers
|
|
|
+ *)
|
|
|
+ PROCEDURE PrintHcRegisters * (regs: HcRegisters);
|
|
|
+ BEGIN
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] HC registers status:"); Log.Ln;
|
|
|
+ Log.String("[SD] SDMASystemAddress: 0x"); Log.Hex(regs.SDMASystemAddress,-SIZEOF(LONGINT)*2); Log.Ln;
|
|
|
+ Log.String("[SD] BlockSize: 0x"); Log.Hex(regs.BlockSize,-SIZEOF(INTEGER)*2); Log.Ln;
|
|
|
+ Log.String("[SD] BlockCount: 0x"); Log.Hex(regs.BlockCount,-SIZEOF(INTEGER)*2); Log.Ln;
|
|
|
+ Log.String("[SD] Argument1: 0x"); Log.Hex(regs.Argument1,-SIZEOF(LONGINT)*2); Log.Ln;
|
|
|
+ Log.String("[SD] TransferMode: 0x"); Log.Hex(regs.TransferMode,-SIZEOF(INTEGER)*2); Log.Ln;
|
|
|
+ Log.String("[SD] Command: 0x"); Log.Hex(regs.Command,-SIZEOF(INTEGER)*2); Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] Response: 0x");
|
|
|
+ Log.Hex(regs.Response[0],-SIZEOF(LONGINT)*2); Log.String(" 0x");
|
|
|
+ Log.Hex(regs.Response[1],-SIZEOF(LONGINT)*2); Log.String(" 0x");
|
|
|
+ Log.Hex(regs.Response[2],-SIZEOF(LONGINT)*2); Log.String(" 0x");
|
|
|
+ Log.Hex(regs.Response[3],-SIZEOF(LONGINT)*2); Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] BufferData: 0x"); Log.Hex(regs.BufferData,-SIZEOF(LONGINT)*2); Log.Ln;
|
|
|
+ Log.String("[SD] PresentState: "); Log.Set(regs.PresentState); Log.Ln;
|
|
|
+ Log.String("[SD] HostControl1: 0x"); Log.Hex(regs.HostControl1,-SIZEOF(SHORTINT)*2); Log.Ln;
|
|
|
+ Log.String("[SD] PowerControl: 0x"); Log.Hex(regs.PowerControl,-SIZEOF(SHORTINT)*2); Log.Ln;
|
|
|
+ Log.String("[SD] BlockGapControl: 0x"); Log.Hex(regs.BlockGapControl,-SIZEOF(SHORTINT)*2); Log.Ln;
|
|
|
+ Log.String("[SD] WakeupControl: 0x"); Log.Hex(regs.WakeupControl,-SIZEOF(SHORTINT)*2); Log.Ln;
|
|
|
+ Log.String("[SD] ClockControl: 0x"); Log.Hex(regs.ClockControl,-SIZEOF(INTEGER)*2); Log.Ln;
|
|
|
+ Log.String("[SD] TimeoutControl: 0x"); Log.Hex(regs.TimeoutControl,-SIZEOF(SHORTINT)*2); Log.Ln;
|
|
|
+ Log.String("[SD] SoftwareReset: 0x"); Log.Hex(regs.SoftwareReset,-SIZEOF(SHORTINT)*2); Log.Ln;
|
|
|
+ Log.String("[SD] InterruptStatus: "); Log.Set(regs.InterruptStatus); Log.Ln;
|
|
|
+ Log.String("[SD] InterruptStatusEnable: "); Log.Set(regs.InterruptStatusEnable); Log.Ln;
|
|
|
+ Log.String("[SD] InterruptSignalEnable: "); Log.Set(regs.InterruptSignalEnable); Log.Ln;
|
|
|
+ Log.String("[SD] AutoCmdErrorStatus: 0x"); Log.Hex(regs.AutoCmdErrorStatus,-SIZEOF(INTEGER)*2); Log.Ln;
|
|
|
+ Log.String("[SD] HostControl2: 0x"); Log.Hex(regs.HostControl2,-SIZEOF(INTEGER)*2); Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] Capabilities: ");
|
|
|
+ Log.Set(regs.Capabilities[0]); Log.String(" ");
|
|
|
+ Log.Set(regs.Capabilities[1]); Log.Ln;
|
|
|
+
|
|
|
+ (*Log.String("[SD] MaximumCurrentCapabilities: 0x"); Log.Hex(regs.MaximumCurrentCapabilities,-SIZEOF(HUGEINT)*2); Log.Ln;
|
|
|
+ Log.String("[SD] ForceEventAutoCmdErrorStatus: 0x"); Log.Hex(regs.ForceEventAutoCmdErrorStatus,-SIZEOF(INTEGER)*2); Log.Ln;
|
|
|
+ Log.String("[SD] ForceEventErrorInterruptStatus: 0x"); Log.Hex(regs.ForceEventErrorInterruptStatus,-SIZEOF(INTEGER)*2); Log.Ln;
|
|
|
+ Log.String("[SD] AdmaErrorStatus: 0x"); Log.Hex(regs.AdmaErrorStatus,-SIZEOF(SHORTINT)*2); Log.Ln;
|
|
|
+ Log.String("[SD] AdmaSystemAddress: 0x"); Log.Hex(regs.AdmaSystemAddress,-SIZEOF(HUGEINT)*2); Log.Ln;*)
|
|
|
+
|
|
|
+ Log.String("[SD] PresetValues: 0x");
|
|
|
+ Log.Hex(regs.PresetValues[0],-SIZEOF(INTEGER)*2); Log.String(" 0x");
|
|
|
+ Log.Hex(regs.PresetValues[1],-SIZEOF(INTEGER)*2); Log.String(" 0x");
|
|
|
+ Log.Hex(regs.PresetValues[2],-SIZEOF(INTEGER)*2); Log.String(" 0x");
|
|
|
+ Log.Hex(regs.PresetValues[3],-SIZEOF(INTEGER)*2); Log.String(" 0x");
|
|
|
+ Log.Hex(regs.PresetValues[4],-SIZEOF(INTEGER)*2); Log.String(" 0x");
|
|
|
+ Log.Hex(regs.PresetValues[5],-SIZEOF(INTEGER)*2); Log.String(" 0x");
|
|
|
+ Log.Hex(regs.PresetValues[6],-SIZEOF(INTEGER)*2); Log.String(" 0x");
|
|
|
+ Log.Hex(regs.PresetValues[7],-SIZEOF(INTEGER)*2); Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] SharedBusControl: 0x"); Log.Hex(regs.SharedBusControl,-SIZEOF(LONGINT)*2); Log.Ln;
|
|
|
+ Log.String("[SD] SlotInterruptStatus: 0x"); Log.Hex(regs.SlotInterruptStatus,-SIZEOF(INTEGER)*2); Log.Ln;
|
|
|
+ Log.String("[SD] HostControllerVersion: 0x"); Log.Hex(regs.HostControllerVersion,-SIZEOF(INTEGER)*2); Log.Ln
|
|
|
+ END
|
|
|
+ END PrintHcRegisters;
|
|
|
+
|
|
|
+ (** Outputs the capabilities of a host controller on the log. *)
|
|
|
+ PROCEDURE PrintCapabilities * (hc: HostController);
|
|
|
+ VAR
|
|
|
+ c0, c1: SET;
|
|
|
+ BEGIN
|
|
|
+ IF EnableTrace THEN
|
|
|
+ c0 := hc.regs.Capabilities[0];
|
|
|
+ c1 := hc.regs.Capabilities[1];
|
|
|
+ Log.String("[SD] "); Log.String("Host Capabilities:"); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Timeout Clock Frequency: ");
|
|
|
+ IF c0 * Capabilities_TimeoutClockFrequencyMask = {} THEN
|
|
|
+ Log.String("Unknown")
|
|
|
+ ELSE
|
|
|
+ Log.Int(SYSTEM.VAL(LONGINT, c0 * Capabilities_TimeoutClockFrequencyMask), 0);
|
|
|
+ IF Capabilities_TimeoutClockUnit IN c0 THEN
|
|
|
+ Log.String(" MHz")
|
|
|
+ ELSE
|
|
|
+ Log.String(" kHz")
|
|
|
+ END
|
|
|
+ END;
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Base Clock Frequency: ");
|
|
|
+ IF c0 * Capabilities_BaseClockFreqSdMask = {} THEN
|
|
|
+ Log.String("Unknown")
|
|
|
+ ELSE
|
|
|
+ Log.Int(LSH(SYSTEM.VAL(LONGINT, c0 * Capabilities_BaseClockFreqSdMask), -Capabilities_BaseClockFreqSdOfs), 0)
|
|
|
+ END;
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Max Block Length: ");
|
|
|
+ Log.Int(512 * (1 + LSH(SYSTEM.VAL(LONGINT, c0 * Capabilities_MaxBlockLenMask), -Capabilities_MaxBlockLenOfs)), 0);
|
|
|
+ Log.String(" B");
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" 8 Bit Support for Embedded Device: ");
|
|
|
+ Log.Boolean(Capabilities_8BitEmbedded IN c0);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Support for ADMA2: ");
|
|
|
+ Log.Boolean(Capabilities_ADMA2 IN c0);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Support for High Speed: ");
|
|
|
+ Log.Boolean(Capabilities_HighSpeed IN c0);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Support for SDMA: ");
|
|
|
+ Log.Boolean(Capabilities_SDMA IN c0);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Support for Suspend/Resume: ");
|
|
|
+ Log.Boolean(Capabilities_SuspendResume IN c0);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Voltage Support for 3.3 V: ");
|
|
|
+ Log.Boolean(Capabilities_Voltage33 IN c0);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Voltage Support for 3.0 V: ");
|
|
|
+ Log.Boolean(Capabilities_Voltage30 IN c0);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Voltage Support for 1.8 V: ");
|
|
|
+ Log.Boolean(Capabilities_Voltage18 IN c0);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Support for 64 Bit Bus: ");
|
|
|
+ Log.Boolean(Capabilities_64BitBus IN c0);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Support for Asynchronous Interrupts: ");
|
|
|
+ Log.Boolean(Capabilities_AsyncInterrupt IN c0);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Slot Type: ");
|
|
|
+ IF c0 * Capabilities_SlotTypeMask = Capabilities_SlotType_Removable THEN
|
|
|
+ Log.String("Removable Card Slot")
|
|
|
+ ELSIF c0 * Capabilities_SlotTypeMask = Capabilities_SlotType_Embedded THEN
|
|
|
+ Log.String("Embedded Slot for One Device")
|
|
|
+ ELSIF c0 * Capabilities_SlotTypeMask = Capabilities_SlotType_SharedBus THEN
|
|
|
+ Log.String("Shared Bus Slot")
|
|
|
+ END;
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ IF hc.version = 3 THEN
|
|
|
+ Log.String("[SD] "); Log.String(" Support for SDR50: ");
|
|
|
+ Log.Boolean(Capabilities_SDR50 IN c1);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Support for SDR104: ");
|
|
|
+ Log.Boolean(Capabilities_SDR104 IN c1);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Support for DDR50: ");
|
|
|
+ Log.Boolean(Capabilities_DDR50 IN c1);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Support for Driver Type A: ");
|
|
|
+ Log.Boolean(Capabilities_DriverTypeA IN c1);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Support for Driver Type C: ");
|
|
|
+ Log.Boolean(Capabilities_DriverTypeC IN c1);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Support for Driver Type D: ");
|
|
|
+ Log.Boolean(Capabilities_DriverTypeD IN c1);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Timer Count for Retuning: ");
|
|
|
+ IF c1 * Capabilities_TimerCountRetuningMask = Capabilities_TimerCountRetuningMask THEN
|
|
|
+ Log.String("Unknown")
|
|
|
+ ELSIF c1 * Capabilities_TimerCountRetuningMask = {} THEN
|
|
|
+ Log.String("Disabled")
|
|
|
+ ELSE
|
|
|
+ Log.Int(LSH(LONGINT(1), LSH(SYSTEM.VAL(LONGINT, c1 * Capabilities_TimerCountRetuningMask), -Capabilities_TimerCountRetuningOfs)), 0);
|
|
|
+ Log.String(" s")
|
|
|
+ END;
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" SDR50 Requires Retuning: ");
|
|
|
+ Log.Boolean(Capabilities_TuningSDR50 IN c1);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Retuning Mode: ");
|
|
|
+ Log.Int(LSH(SYSTEM.VAL(LONGINT, c1 * Capabilities_RetuningModesMask), -Capabilities_RetuningModesOfs), 0);
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Clock Multiplier: ");
|
|
|
+ IF c1 * Capabilities_ClockMultiplierMask = {} THEN
|
|
|
+ Log.String("Not Supported")
|
|
|
+ ELSE
|
|
|
+ Log.Int(LSH(SYSTEM.VAL(LONGINT, c1 * Capabilities_ClockMultiplierMask), -Capabilities_ClockMultiplierOfs) + 1, 0)
|
|
|
+ END;
|
|
|
+ Log.Ln
|
|
|
+ END
|
|
|
+ END
|
|
|
+ END PrintCapabilities;
|
|
|
+
|
|
|
+ (** Print a card status response on the log. *)
|
|
|
+ PROCEDURE PrintCardStatus * (status: SET);
|
|
|
+ BEGIN
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] Card Status:"); Log.Ln;
|
|
|
+ Log.String("[SD] AKE Error: "); Log.Boolean(CardStatus_AkeSpecError IN status); Log.Ln;
|
|
|
+ Log.String("[SD] App Command: "); Log.Boolean(CardStatus_AppCmd IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Ready For Data: "); Log.Boolean(CardStatus_ReadyForData IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Card State: ");
|
|
|
+ CASE LSH(SYSTEM.VAL(LONGINT, status * CardStatus_CurrentStateMask), -CardStatus_CurrentStateOffset) OF
|
|
|
+ CardIdle: Log.String("Idle")
|
|
|
+ |CardReady: Log.String("Ready")
|
|
|
+ |CardIdentification: Log.String("Identification")
|
|
|
+ |CardStandby: Log.String("Standby")
|
|
|
+ |CardTransfer: Log.String("Transfer")
|
|
|
+ |CardData: Log.String("Sending Data")
|
|
|
+ |CardReceive: Log.String("Receiving Data")
|
|
|
+ |CardProgram: Log.String("Programming")
|
|
|
+ |CardDisabled: Log.String("Disabled")
|
|
|
+ END;
|
|
|
+ Log.Ln;
|
|
|
+ Log.String("[SD] Erase Reset: "); Log.Boolean(CardStatus_EraseReset IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Internal ECC Enable: "); Log.Boolean(CardStatus_CardEccDisable IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Write_Protection Erase Skip: "); Log.Boolean(CardStatus_WpEraseSkip IN status); Log.Ln;
|
|
|
+ Log.String("[SD] CSD Overwrite: "); Log.Boolean(CardStatus_CsdOverwrite IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Error: "); Log.Boolean(CardStatus_Error IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Card Controller Error: "); Log.Boolean(CardStatus_CcError IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Card ECC Failed: "); Log.Boolean(CardStatus_CardEccFailed IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Illegal Command: "); Log.Boolean(CardStatus_IllegalCommand IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Command CRC Error: "); Log.Boolean(CardStatus_ComCrcError IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Lock/Unlock Failed: "); Log.Boolean(CardStatus_LockUnlockFailed IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Card is Locked: "); Log.Boolean(CardStatus_CardIsLocked IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Write-Protection Violation: "); Log.Boolean(CardStatus_WpViolation IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Invalid Erase Parameters: "); Log.Boolean(CardStatus_EraseParam IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Erase Sequence Error: "); Log.Boolean(CardStatus_EraseSeqError IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Block Length Error: "); Log.Boolean(CardStatus_BlockLenError IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Address Error: "); Log.Boolean(CardStatus_AddressError IN status); Log.Ln;
|
|
|
+ Log.String("[SD] Argument Out of Range: "); Log.Boolean(CardStatus_OutOfRange IN status); Log.Ln
|
|
|
+ END
|
|
|
+ END PrintCardStatus;
|
|
|
+
|
|
|
+ (** Print SD Status record *)
|
|
|
+ PROCEDURE PrintSdStatus * (status: SdStatus);
|
|
|
+ BEGIN
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] SD Status"); Log.Ln;
|
|
|
+ Log.String("[SD] data bus width: "); Log.Int(status.dataBusWidth, 0); Log.Ln;
|
|
|
+ Log.String("[SD] secured mode enabled: "); Log.Boolean(status.securedMode); Log.Ln;
|
|
|
+ Log.String("[SD] cardType: ");
|
|
|
+ CASE status.cardType OF
|
|
|
+ CategoryRW: Log.String("normal RW card")
|
|
|
+ |CategoryRO: Log.String("read-only card")
|
|
|
+ |CategoryOTP: Log.String("one-time programmable card")
|
|
|
+ END; Log.Ln;
|
|
|
+ Log.String("[SD] size of protected area: "); PrintSize(status.sizeProtArea); Log.Ln;
|
|
|
+ Log.String("[SD] move performance: ");
|
|
|
+ CASE status.perfMove OF
|
|
|
+ 0: Log.String("sequential write")
|
|
|
+ |255: Log.String("infinite")
|
|
|
+ ELSE
|
|
|
+ Log.Int(status.perfMove, 0);
|
|
|
+ Log.String(" MB/s")
|
|
|
+ END; Log.Ln;
|
|
|
+ Log.String("[SD] erase size: "); Log.Int(status.eraseSize, 0); Log.String(" AUs"); Log.Ln;
|
|
|
+ Log.String("[SD] erase timeout: ");
|
|
|
+ IF status.eraseTimeout = 0 THEN
|
|
|
+ Log.String("not supported")
|
|
|
+ ELSE
|
|
|
+ Log.Int(status.eraseTimeout, 0); Log.String(" s")
|
|
|
+ END; Log.Ln;
|
|
|
+ Log.String("[SD] erase timeout offset: "); Log.Int(status.eraseOffset, 0); Log.String(" s"); Log.Ln;
|
|
|
+ Log.String("[SD] speed class: "); Log.Int(status.speedClass, 0); Log.Ln;
|
|
|
+ Log.String("[SD] AU size: "); PrintSize(status.auSize); Log.Ln;
|
|
|
+ Log.String("[SD] UHS speed grade: "); Log.Int(status.uhsSpeedGrade, 0); Log.Ln;
|
|
|
+ Log.String("[SD] UHS AU size: "); PrintSize(status.uhsAuSize); Log.Ln;
|
|
|
+ Log.String("[SD] video speed class: "); Log.Int(status.vscSpeedClass, 0); Log.Ln;
|
|
|
+ Log.String("[SD] VSC AU size: "); PrintSize(status.vscAuSize); Log.Ln;
|
|
|
+ Log.String("[SD] suspension address: "); Log.Int(status.suspensionAdr, 0); Log.Ln;
|
|
|
+ Log.String("[SD] application performance class: ");
|
|
|
+ IF status.appPerfClass = 0 THEN
|
|
|
+ Log.String("not supported")
|
|
|
+ ELSE
|
|
|
+ Log.String("A");
|
|
|
+ Log.Int(status.appPerfClass, 0)
|
|
|
+ END; Log.Ln;
|
|
|
+ Log.String("[SD] performance enhance: ");
|
|
|
+ IF status.perfEnhance = {} THEN Log.String("none") END;
|
|
|
+ IF PerformanceCardMaintenance IN status.perfEnhance THEN Log.String("card-initiated maintenance; ") END;
|
|
|
+ IF PerformanceHostMaintenance IN status.perfEnhance THEN Log.String("host-initiated maintenance; ") END;
|
|
|
+ IF PerformanceCache IN status.perfEnhance THEN Log.String("cache; ") END;
|
|
|
+ IF PerformanceQueue IN status.perfEnhance THEN
|
|
|
+ Log.String("command queue;"); Log.Ln;
|
|
|
+ Log.String("[SD] command queue depth: ");
|
|
|
+ Log.Int(status.commandQueueDepth, 0)
|
|
|
+ END; Log.Ln;
|
|
|
+ Log.String("[SD] discard supported: "); Log.Boolean(status.discardSupport); Log.Ln;
|
|
|
+ Log.String("[SD] FULE supported: "); Log.Boolean(status.fuleSupport); Log.Ln
|
|
|
+ END
|
|
|
+ END PrintSdStatus;
|
|
|
+
|
|
|
+ (** Print the CID of a card to the log. *)
|
|
|
+ PROCEDURE PrintCardCid * (cid: Cid);
|
|
|
+ BEGIN
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] CID"); Log.Ln;
|
|
|
+ Log.String("[SD] manufacturing date: "); Log.Int(cid.manufacturingDate.month, 0); Log.String("/"); Log.Int(cid.manufacturingDate.year, 0); Log.Ln;
|
|
|
+ Log.String("[SD] product serial number: "); Log.Int(cid.productSerialNumber, 0); Log.Ln;
|
|
|
+ Log.String("[SD] product revision: "); Log.Int(cid.productRevision.n, 0); Log.String("."); Log.Int(cid.productRevision.m, 0); Log.Ln;
|
|
|
+ Log.String("[SD] product name: "); Log.String(cid.productName); Log.Ln;
|
|
|
+ Log.String("[SD] OEM/application id: "); Log.String(cid.oemId); Log.Ln;
|
|
|
+ Log.String("[SD] manufacturer id: "); Log.Int(cid.manufacturerId, 0); Log.Ln
|
|
|
+ END
|
|
|
+ END PrintCardCid;
|
|
|
+
|
|
|
+ (** Print the CSD of a card to the log. *)
|
|
|
+ PROCEDURE PrintCardCsd * (CONST csd: ARRAY OF LONGINT);
|
|
|
+ VAR
|
|
|
+ cap: HUGEINT;
|
|
|
+ val, version, sizeMult: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ IF EnableTrace THEN
|
|
|
+ version := ReadBitfield(csd, CardCsd_CsdStructureOfs, CardCsd_CsdStructureWidth) + 1;
|
|
|
+ Log.String("[SD] "); Log.String("Card CSD:"); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Version: "); Log.Int(version, 0); Log.Ln;
|
|
|
+
|
|
|
+ (* Common Fields *)
|
|
|
+ Log.String("[SD] "); Log.String(" File Format: ");
|
|
|
+ val := ReadBitfield(csd, CardCsd_FileFormatOfs, CardCsd_FileFormatWidth);
|
|
|
+ IF ReadBitfield(csd, CardCsd_FileFormatGrp, 1) = 1 THEN
|
|
|
+ Log.String("Unknown Value (");
|
|
|
+ Log.Int(val, 0);
|
|
|
+ Log.String(")")
|
|
|
+ ELSIF val = 0 THEN
|
|
|
+ Log.String("Hard-disk file system with partition table")
|
|
|
+ ELSIF val = 1 THEN
|
|
|
+ Log.String("FAT")
|
|
|
+ ELSIF val = 2 THEN
|
|
|
+ Log.String("Universal File Format")
|
|
|
+ ELSE
|
|
|
+ Log.String("Other")
|
|
|
+ END;
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Temporary Write Protection: "); Log.Boolean(ReadBitfield(csd, CardCsd_TmpWriteProtect, 1) = 1); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Permanent Write Protection: "); Log.Boolean(ReadBitfield(csd, CardCsd_PermWriteProtect, 1) = 1); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Copy: "); Log.Boolean(ReadBitfield(csd, CardCsd_Copy, 1) = 1); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Partial Block Write: "); Log.Boolean(ReadBitfield(csd, CardCsd_WriteBlPartial, 1) = 1); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Maximum Write Block Length: ");
|
|
|
+ val := ReadBitfield(csd, CardCsd_WriteBlLenOfs, CardCsd_WriteBlLenWidth);
|
|
|
+ IF (val <= 8) OR (val >= 12) THEN
|
|
|
+ Log.String("Unknown Value (");
|
|
|
+ Log.Int(val, 0);
|
|
|
+ Log.String(")")
|
|
|
+ ELSE
|
|
|
+ Log.Int(LSH(LONGINT(1), val), 0);
|
|
|
+ END;
|
|
|
+ Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Block Program Time / Block Read Time: ");
|
|
|
+ val := ReadBitfield(csd, CardCsd_R2wFactorOfs, CardCsd_R2wFactorWidth);
|
|
|
+ IF val >= 6 THEN
|
|
|
+ Log.String("Unknown Value (");
|
|
|
+ Log.Int(val, 0);
|
|
|
+ Log.String(")")
|
|
|
+ ELSE
|
|
|
+ Log.Int(LSH(LONGINT(1), val), 0);
|
|
|
+ END;
|
|
|
+ Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Group Write Protection: "); Log.Boolean(ReadBitfield(csd, CardCsd_WpGrpEnable, 1) = 1); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" WpGrpSize: "); Log.Int(ReadBitfield(csd, CardCsd_WpGrpSizeOfs, CardCsd_WpGrpSizeWidth) + 1, 0); Log.String(" sectors"); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Sector Size: "); Log.Int(ReadBitfield(csd, CardCsd_SectorSizeOfs, CardCsd_SectorSizeWidth) + 1, 0); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Erase Block Enable: "); Log.Boolean(ReadBitfield(csd, CardCsd_EraseBlkEn, 1) = 1); Log.Ln;
|
|
|
+
|
|
|
+ IF version = 1 THEN
|
|
|
+ sizeMult := LSH(LONGINT(2), ReadBitfield(csd, CardCsd_CSizeMultOfs1, CardCsd_CSizeMultWidth1));
|
|
|
+ cap := sizeMult * (1 + ReadBitfield(csd, CardCsd_CSizeOfs1, CardCsd_CSizeWidth1)) * 512;
|
|
|
+ ELSE
|
|
|
+ cap := 512 * 1024 * (HUGEINT(ReadBitfield(csd, CardCsd_CSizeOfs2, CardCsd_CSizeWidth2)) + 1);
|
|
|
+ END;
|
|
|
+ Log.String("[SD] "); Log.String(" Card Capacity: "); Log.Int(cap, 0); Log.String(" B"); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" DSR Implemented: "); Log.Boolean(ReadBitfield(csd, CardCsd_DsrImp, 1) = 1); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Misaligned Block Read: "); Log.Boolean(ReadBitfield(csd, CardCsd_ReadBlkMisalign, 1) = 1); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Misaligned Block Write: "); Log.Boolean(ReadBitfield(csd, CardCsd_WriteBlkMisalign, 1) = 1); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Partial Block Read: "); Log.Boolean(ReadBitfield(csd, CardCsd_ReadBlPartial, 1) = 1); Log.Ln;
|
|
|
+ (*ASSERT(ReadBitfield(csd, CardCsd_ReadBlPartial, 1) = 1);*)
|
|
|
+ Log.String("[SD] "); Log.String(" Maximal Block Read Length: ");
|
|
|
+ val := ReadBitfield(csd, CardCsd_ReadBlLenOfs, CardCsd_ReadBlLenWidth);
|
|
|
+ IF (val <= 8) OR (val >= 12) THEN
|
|
|
+ Log.String("Unknown Value (");
|
|
|
+ Log.Int(val, 0);
|
|
|
+ Log.String(")")
|
|
|
+ ELSE
|
|
|
+ Log.Int(LSH(LONGINT(1), val), 0); Log.String(" B")
|
|
|
+ END;
|
|
|
+ Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Supported Command Classes: "); Log.Set(SYSTEM.VAL(SET, ReadBitfield(csd, CardCsd_CccOfs, CardCsd_CccWidth))); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Transfer Speed: ");
|
|
|
+ val := ReadBitfield(csd, CardCsd_TranSpeedOfs, CardCsd_TranSpeedWidth);
|
|
|
+ CASE val DIV 8 OF
|
|
|
+ 1: Log.String("1.0")
|
|
|
+ |2: Log.String("1.2")
|
|
|
+ |3: Log.String("1.3")
|
|
|
+ |4: Log.String("1.5")
|
|
|
+ |5: Log.String("2.0")
|
|
|
+ |6: Log.String("2.0")
|
|
|
+ |7: Log.String("2.5")
|
|
|
+ |8: Log.String("3.5")
|
|
|
+ |9: Log.String("4.0")
|
|
|
+ |10: Log.String("4.5")
|
|
|
+ |11: Log.String("5.0")
|
|
|
+ |12: Log.String("5.5")
|
|
|
+ |13: Log.String("6.0")
|
|
|
+ |14: Log.String("7.0")
|
|
|
+ |15: Log.String("8.0")
|
|
|
+ ELSE
|
|
|
+ Log.String("Unknown Value (");
|
|
|
+ Log.Int(val, 0);
|
|
|
+ Log.String(")")
|
|
|
+ END;
|
|
|
+ Log.String(" * 1");
|
|
|
+ CASE val MOD 8 OF
|
|
|
+ 0: Log.String("00 k")
|
|
|
+ |1: Log.String(" M")
|
|
|
+ |2: Log.String("0 M")
|
|
|
+ |3: Log.String("00 M")
|
|
|
+ END;
|
|
|
+ Log.String("Bit/s");
|
|
|
+ Log.Ln;
|
|
|
+
|
|
|
+ Log.String("[SD] "); Log.String(" Clock-Dependent Access Time: "); Log.Int(ReadBitfield(csd, CardCsd_NsacOfs, CardCsd_NsacWidth) * 100, 0); Log.String("000 clock cycles"); Log.Ln;
|
|
|
+ Log.String("[SD] "); Log.String(" Asynchronous Access Time: ");
|
|
|
+ val := ReadBitfield(csd, CardCsd_TaacOfs, CardCsd_TaacWidth);
|
|
|
+ CASE val DIV 8 OF
|
|
|
+ 1: Log.String("1.0")
|
|
|
+ |2: Log.String("1.2")
|
|
|
+ |3: Log.String("1.3")
|
|
|
+ |4: Log.String("1.5")
|
|
|
+ |5: Log.String("2.0")
|
|
|
+ |6: Log.String("2.5")
|
|
|
+ |7: Log.String("3.0")
|
|
|
+ |8: Log.String("3.5")
|
|
|
+ |9: Log.String("4.0")
|
|
|
+ |10: Log.String("4.5")
|
|
|
+ |11: Log.String("5.0")
|
|
|
+ |12: Log.String("5.5")
|
|
|
+ |13: Log.String("6.0")
|
|
|
+ |14: Log.String("7.0")
|
|
|
+ |15: Log.String("8.0")
|
|
|
+ ELSE
|
|
|
+ Log.String("Unknown Value (");
|
|
|
+ Log.Int(val, 0);
|
|
|
+ Log.String(")")
|
|
|
+ END;
|
|
|
+ Log.String(" * 1");
|
|
|
+ CASE val MOD 8 OF
|
|
|
+ 0: Log.String(" ns")
|
|
|
+ |1: Log.String("0 ns")
|
|
|
+ |2: Log.String("00 ns")
|
|
|
+ |3: Log.String(" microsecond")
|
|
|
+ |4: Log.String("0 microsecond")
|
|
|
+ |5: Log.String("00 microsecond")
|
|
|
+ |6: Log.String(" ms")
|
|
|
+ |7: Log.String("0 ms")
|
|
|
+ END;
|
|
|
+ Log.Ln
|
|
|
+ END
|
|
|
+ END PrintCardCsd;
|
|
|
+
|
|
|
+ PROCEDURE PrintCardScr * (CONST scr: Scr);
|
|
|
+ VAR i: LONGINT;
|
|
|
+ BEGIN
|
|
|
+ IF EnableTrace THEN
|
|
|
+ Log.String("[SD] Card SCR"); Log.Ln;
|
|
|
+ Log.String("[SD] physical layer version: ");
|
|
|
+ CASE scr.version OF
|
|
|
+ Version1: Log.String("1")
|
|
|
+ |Version1p1: Log.String("1.1")
|
|
|
+ |Version2: Log.String("2")
|
|
|
+ |Version3: Log.String("3")
|
|
|
+ |Version4: Log.String("4")
|
|
|
+ |Version5: Log.String("5")
|
|
|
+ |Version6: Log.String("6")
|
|
|
+ ELSE
|
|
|
+ Log.String("unknown")
|
|
|
+ END;
|
|
|
+ Log.Ln;
|
|
|
+ Log.String("[SD] security support: ");
|
|
|
+ CASE scr.security OF
|
|
|
+ TypeNone: Log.String("none")
|
|
|
+ |TypeSDSC: Log.String("SDSC")
|
|
|
+ |TypeSDHC: Log.String("SDHC")
|
|
|
+ |TypeSDXC: Log.String("SDXC")
|
|
|
+ END;
|
|
|
+ Log.Ln;
|
|
|
+ Log.String("[SD] supported bus widths: "); Log.Set(scr.busWidth); Log.Ln
|
|
|
+ END
|
|
|
+ END PrintCardScr;
|
|
|
+
|
|
|
+ (** Helper to write a size in a human-readable format *)
|
|
|
+ PROCEDURE PrintSize (size: HUGEINT);
|
|
|
+ VAR
|
|
|
+ prefix: ARRAY 8 OF CHAR;
|
|
|
+ i: LONGINT;
|
|
|
+
|
|
|
+ BEGIN
|
|
|
+ IF size < 1024 THEN
|
|
|
+ Log.Int(size, 0);
|
|
|
+ Log.String(" ")
|
|
|
+ ELSE
|
|
|
+ prefix := 'kMGT';
|
|
|
+ i := 0;
|
|
|
+ size := size DIV 1024;
|
|
|
+ WHILE size > 1024 DO
|
|
|
+ size := size DIV 1024;
|
|
|
+ INC(i)
|
|
|
+ END;
|
|
|
+ Log.Int(size, 0);
|
|
|
+ Log.String(" ");
|
|
|
+ Log.Char(prefix[i])
|
|
|
+ END;
|
|
|
+ Log.String("B")
|
|
|
+ END PrintSize;
|
|
|
+
|
|
|
+ (**
|
|
|
+ Helper procedure to read bit fields in a wide register.
|
|
|
+ field: large bitfield
|
|
|
+ ofs: offset of first bit to extract
|
|
|
+ width: number of bits to extract
|
|
|
+ Returns the bits as a LONGINT.
|
|
|
+ *)
|
|
|
+ PROCEDURE ReadBitfield (CONST field: ARRAY OF LONGINT; ofs, width: LONGINT): LONGINT;
|
|
|
+ VAR
|
|
|
+ adr, bits: ADDRESS;
|
|
|
+ BEGIN
|
|
|
+ ASSERT(ofs MOD 8 + width <= 32);
|
|
|
+ adr := ADDRESSOF(field[0]) + ofs DIV 8;
|
|
|
+ bits := SYSTEM.GET8(adr) MOD 100H;
|
|
|
+ IF ofs MOD 8 + width > 8 THEN
|
|
|
+ bits := bits + LSH(ADDRESS(SYSTEM.GET8(adr + 1)) MOD 100H, 8);
|
|
|
+ END;
|
|
|
+ IF ofs MOD 8 + width > 16 THEN
|
|
|
+ bits := bits + LSH(ADDRESS(SYSTEM.GET8(adr + 2)) MOD 100H, 16);
|
|
|
+ END;
|
|
|
+ IF ofs MOD 8 + width > 24 THEN
|
|
|
+ bits := bits + LSH(ADDRESS(SYSTEM.GET8(adr + 3)) MOD 100H, 24)
|
|
|
+ END;
|
|
|
+ RETURN SYSTEM.VAL(LONGINT, SYSTEM.VAL(SET, LSH(bits, -(ofs MOD 8))) * {0 .. width - 1})
|
|
|
+ END ReadBitfield;
|
|
|
+
|
|
|
+ PROCEDURE ReadBit (CONST field: ARRAY OF LONGINT; bit: LONGINT): BOOLEAN;
|
|
|
+ BEGIN
|
|
|
+ RETURN SYSTEM.VAL(BOOLEAN, LSH(SYSTEM.GET8(ADDRESSOF(field[0])) + bit DIV 8, -(bit MOD 8)))
|
|
|
+ END ReadBit;
|
|
|
+
|
|
|
+ PROCEDURE ResetStatistics *;
|
|
|
+ BEGIN
|
|
|
+ NbyteRead := 0;
|
|
|
+ Nread := 0;
|
|
|
+ Tread := 0;
|
|
|
+ NbyteWritten := 0;
|
|
|
+ Nwrite := 0;
|
|
|
+ Twrite := 0
|
|
|
+ END ResetStatistics;
|
|
|
+END Sd.
|
eth.morozova