/*
* Copyright (c) 2015 Jarielle Catbagan <jcatbagan93@gmail.com>
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.apache.org/licenses/LICENSE-2.0
*/
#include "stddefs.h"
#include "am335x.h"
#include "sd.h"
uint16_t sdrca;
int
sdcmd(uint32_t cmd, uint32_t arg, uint32_t resp[4])
{
/* Clear the SD_STAT register for proper update of status bits after CMD invocation */
MMCHS0_REG(SD_STAT) = 0xFFFFFFFF;
MMCHS0_REG(SD_ARG) = arg;
MMCHS0_REG(SD_CMD) = cmd;
/* CMDx complete? */
while (!(MMCHS0_REG(SD_STAT) & (SD_STAT_CC | SD_STAT_ERRI)));
resp[0] = MMCHS0_REG(SD_RSP10);
resp[1] = MMCHS0_REG(SD_RSP32);
resp[2] = MMCHS0_REG(SD_RSP54);
resp[3] = MMCHS0_REG(SD_RSP76);
/* CMDx error? */
if (MMCHS0_REG(SD_STAT) & SD_STAT_ERRI)
return(-1);
else
return(0);
}
int
sdCardCmd(int interface, int cmd, unsigned long arg, unsigned char *resp)
{
return(-1);
}
int
sdInit(int interface, int verbosity)
{
uint32_t cmd, arg, resp[4];
/* Reset the MMC/SD controller */
MMCHS0_REG(SD_SYSCONFIG) = SD_SYSCONFIG_SOFTRESET;
while (!(MMCHS0_REG(SD_SYSSTATUS) & SD_SYSSTATUS_RESETDONE));
/* Reset the command and data lines */
MMCHS0_REG(SD_SYSCTL) |= SD_SYSCTL_SRA;
while (MMCHS0_REG(SD_SYSCTL) & SD_SYSCTL_SRA);
/* Configure the MMC/SD controller capabilities to enable 3.0 V operating voltage */
MMCHS0_REG(SD_CAPA) = SD_CAPA_VS30;
/* Configure SD_IE register to update certain status bits in SD_STAT */
MMCHS0_REG(SD_IE) = SD_IE_BADA_ENABLE | SD_IE_CERR_ENABLE | SD_IE_ACE_ENABLE |
SD_IE_DEB_ENABLE | SD_IE_DCRC_ENABLE | SD_IE_DTO_ENABLE | SD_IE_CIE_ENABLE |
SD_IE_CEB_ENABLE | SD_IE_CCRC_ENABLE | SD_IE_CIRQ_ENABLE | SD_IE_CREM_ENABLE |
SD_IE_CINS_ENABLE | SD_IE_BRR_ENABLE | SD_IE_BWR_ENABLE |
SD_IE_TC_ENABLE | SD_IE_CC_ENABLE;
/* Disable open-drain mode (only used for MMC cards) and 8-bit data width */
MMCHS0_REG(SD_CON) &= ~(SD_CON_OD | SD_CON_DW8);
/* Configure the operating voltage to 3.0 V */
MMCHS0_REG(SD_HCTL) &= ~(SD_HCTL_SDVS);
MMCHS0_REG(SD_HCTL) |= SD_HCTL_SDVS_VS30;
/* Set the data width to 4-bits */
MMCHS0_REG(SD_HCTL) |= SD_HCTL_DTW;
/* Turn on the bus */
MMCHS0_REG(SD_HCTL) |= SD_HCTL_SDBP;
while (!(MMCHS0_REG(SD_HCTL) & SD_HCTL_SDBP));
/* Enable the internal clock */
MMCHS0_REG(SD_SYSCTL) |= SD_SYSCTL_ICE;
/* Configure Clock Frequency Select to 100 KHz */
MMCHS0_REG(SD_SYSCTL) = (MMCHS0_REG(SD_SYSCTL) & ~(SD_SYSCTL_CLKD)) | (960 << 6);
/* Wait for clock to stabilize */
while (!(MMCHS0_REG(SD_SYSCTL) & SD_SYSCTL_ICS));
/* Configure SD_SYSCONFIG */
MMCHS0_REG(SD_SYSCONFIG) &= ~(SD_SYSCONFIG_CLOCKACTIVITY | SD_SYSCONFIG_SIDLEMODE);
MMCHS0_REG(SD_SYSCONFIG) |= SD_SYSCONFIG_SIDLEMODE_WKUP | SD_SYSCONFIG_ENAWAKEUP_ENABLE |
SD_SYSCONFIG_AUTOIDLE_AUTOGATE;
/* Enable the clock to the SD card */
MMCHS0_REG(SD_SYSCTL) |= SD_SYSCTL_CEN_ENABLE;
/* Perform the Initialization Stream as specified in the AM335x TRM, Section 18.3.3.2
"Card Detection, Identicication, and Selection" */
MMCHS0_REG(SD_CON) |= SD_CON_INIT;
/* Clear the SD_STAT register */
MMCHS0_REG(SD_STAT) = 0xFFFFFFFF;
MMCHS0_REG(SD_ARG) = 0x00000000;
MMCHS0_REG(SD_CMD) = 0x00000000;
while (!(MMCHS0_REG(SD_STAT) & SD_STAT_CC));
/* Clear CC flag in SD_STAT */
MMCHS0_REG(SD_STAT) |= SD_STAT_CC;
MMCHS0_REG(SD_CON) &= ~SD_CON_INIT;
/* Change the clock frequency to 6 MHz and set the DTO to the maximum value setting */
MMCHS0_REG(SD_SYSCTL) &= ~SD_SYSCTL_DTO;
MMCHS0_REG(SD_SYSCTL) |= SD_SYSCTL_DTO_TCF_2_27;
MMCHS0_REG(SD_SYSCTL) = (MMCHS0_REG(SD_SYSCTL) & ~SD_SYSCTL_CLKD) | (16 << 6);
/* Wait for clock to stabilize */
while ((MMCHS0_REG(SD_SYSCTL) & SD_SYSCTL_ICS) != SD_SYSCTL_ICS);
/* Send CMD0/GO_IDLE_STATE to reset the SD card connected to MMC0 interface */
arg = 0x00000000;
cmd = SD_CMD_CMD0_GO_IDLE_STATE | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_DISABLE | SD_CMD_CCCE_DISABLE | SD_CMD_RSP_TYPE_NO_RESPONSE;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Send CMD8/SEND_IF_COND to verify that the SD card satisfies MMC/SD controller
requirements */
arg = 0x00000188;
cmd = SD_CMD_CMD8_SEND_IF_COND | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R7;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Determine what type of SD card is connected, i.e. standard capacity, high capacity, etc.
* We perform a CMD55/ACMD41 loop until the "Card power up status bit" is set in the OCR
* register from the SD card to determine when we have a valid response */
do {
arg = 0x00000000;
cmd = SD_CMD_CMD55_APP_CMD | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R1;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
arg = 0x40060000;
cmd = SD_CMD_ACMD41_SD_SEND_OP_COND | SD_CMD_CMD_TYPE_NORMAL |
SD_CMD_DP_NO_DATA_PRESENT | SD_CMD_CICE_DISABLE | SD_CMD_CCCE_DISABLE |
SD_CMD_RSP_TYPE_R3;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
} while (!(resp[0] & SD_RSP10_R3_CARD_POWER_UP_STATUS));
/* Check SD_RSP10 to determine whether the card connected is high capacity or not */
if (resp[0] & SD_RSP10_R3_CARD_CAPACITY_STATUS)
sdInfoTbl[interface].highcapacity = 1;
else
sdInfoTbl[interface].highcapacity = 0;
/* Send CMD2 to get SD's CID and to put the card into Identification State */
arg = 0x00000000;
cmd = SD_CMD_CMD2_ALL_SEND_CID | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_DISABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R2;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Send CMD3, i.e. request new relative address (RCA) and to put the card into
Stand-by State */
arg = 0x00000000;
cmd = SD_CMD_CMD3_SEND_RELATIVE_ADDR | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R6;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Save the RCA published from the SD card, this will be used in future CMDx commands */
sdrca = (MMCHS0_REG(SD_RSP10) >> 16) & 0xFFFF;
/* Wait for the SD card to enter Stand-by State */
do {
arg = (sdrca << 16) & 0xFFFF0000;
cmd = SD_CMD_CMD13_SEND_STATUS | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R1;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
} while ((resp[0] & SD_RSP10_R1_CURRENT_STATE) != SD_RSP10_R1_CURRENT_STATE_STANDBY);
/* Put the card with the RCA obtained previously into Transfer State via CMD7 */
arg = (sdrca << 16) & 0xFFFF0000;
cmd = SD_CMD_CMD7_SELECT_DESELECT_CARD | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R1B;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Wait for the SD card to enter Transfer State */
do {
arg = (sdrca << 16) & 0xFFFF0000;
cmd = SD_CMD_CMD13_SEND_STATUS | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R1;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
} while ((resp[0] & SD_RSP10_R1_CURRENT_STATE) != SD_RSP10_R1_CURRENT_STATE_TRANSFER);
/* Set the bus-width to 4-bits */
/* Send CMD55 to get ready to configure the bus-width via ACMD6 */
arg = (sdrca << 16) & 0xFFFF0000;
cmd = SD_CMD_CMD55_APP_CMD | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R1;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Send ACMD6, SET_BUS_WIDTH to set the bus-width to 4-bits */
arg = 0x00000002;
cmd = SD_CMD_ACMD6_SET_BUS_WIDTH | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R1;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Put the SD card into Stand-by State */
arg = 0x00000000;
cmd = SD_CMD_CMD7_SELECT_DESELECT_CARD | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_NO_RESPONSE;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Wait for the SD card to enter Stand-by State */
do {
arg = (sdrca << 16) & 0xFFFF0000;
cmd = SD_CMD_CMD13_SEND_STATUS | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R1;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
} while ((resp[0] & SD_RSP10_R1_CURRENT_STATE) != SD_RSP10_R1_CURRENT_STATE_STANDBY);
/* This point is reached when SD controller initialization and SD card
communication is successful */
return(0);
}
int
sdRead(int interface, char *buf, int blknum, int blkcount)
{
uint32_t cmd, arg, resp[4];
uint32_t *wordptr = (uint32_t *) buf;
int byteindex;
/* Get the SD card's status via CMD13 */
arg = (sdrca << 16) & 0xFFFF0000;
cmd = SD_CMD_CMD13_SEND_STATUS | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R1;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Ensure that the card is in Transfer State before proceeding */
if ((resp[0] & SD_RSP10_R1_CURRENT_STATE) != SD_RSP10_R1_CURRENT_STATE_TRANSFER) {
arg = (sdrca << 16) & 0xFFFF0000;
cmd = SD_CMD_CMD7_SELECT_DESELECT_CARD | SD_CMD_CMD_TYPE_NORMAL |
SD_CMD_DP_NO_DATA_PRESENT | SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE |
SD_CMD_RSP_TYPE_R1B;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Wait for the SD card to enter Transfer State */
do {
arg = (sdrca << 16) & 0xFFFF0000;
cmd = SD_CMD_CMD13_SEND_STATUS | SD_CMD_CMD_TYPE_NORMAL |
SD_CMD_DP_NO_DATA_PRESENT | SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE |
SD_CMD_RSP_TYPE_R1;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
} while ((resp[0] & SD_RSP10_R1_CURRENT_STATE) != SD_RSP10_R1_CURRENT_STATE_TRANSFER);
}
/* Set the block length and the number of blocks to read */
MMCHS0_REG(SD_BLK) = SD_BLKSIZE | (blkcount << 16);
/* Send CMD18, i.e. read multiple blocks */
arg = blknum;
cmd = SD_CMD_CMD18_READ_MULTIPLE_BLOCK | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R1 | SD_CMD_MSBS_MULTIPLE |
SD_CMD_DDIR_READ | SD_CMD_ACEN_CMD12_ENABLE | SD_CMD_BCE_ENABLE;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Check the data buffer to see if there is data to be read */
do {
while (!(MMCHS0_REG(SD_STAT) & SD_STAT_BRR));
/* Clear the BRR status bit in SD_STAT */
MMCHS0_REG(SD_STAT) |= SD_STAT_BRR;
for (byteindex = 0; byteindex < (SD_BLKSIZE / 4); byteindex++) {
*wordptr = (MMCHS0_REG(SD_DATA));
wordptr++;
}
} while (!(MMCHS0_REG(SD_STAT) & SD_STAT_TC));
/* Put the SD card into Stand-by State */
arg = 0;
cmd = SD_CMD_CMD7_SELECT_DESELECT_CARD | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_NO_RESPONSE;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Wait for the SD card to enter Stand-by State */
do {
arg = (sdrca << 16) & 0xFFFF0000;
cmd = SD_CMD_CMD13_SEND_STATUS | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R1;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
} while ((resp[0] & SD_RSP10_R1_CURRENT_STATE) != SD_RSP10_R1_CURRENT_STATE_STANDBY);
return(0);
}
int
sdWrite(int interface, char *buf, int blknum, int blkcount)
{
uint32_t cmd, arg, resp[4];
uint32_t *wordptr = (uint32_t *) buf;
int byteindex;
/* Get the SD card's status by sending CMD13 */
arg = (sdrca << 16) & 0xFFFF0000;
cmd = SD_CMD_CMD13_SEND_STATUS | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R1;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Ensure that the card is in the Transfer State before proceeding */
if ((resp[0] & SD_RSP10_R1_CURRENT_STATE) != SD_RSP10_R1_CURRENT_STATE_TRANSFER) {
arg = (sdrca << 16) & 0xFFFF0000;
cmd = SD_CMD_CMD7_SELECT_DESELECT_CARD | SD_CMD_CMD_TYPE_NORMAL |
SD_CMD_DP_NO_DATA_PRESENT | SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE |
SD_CMD_RSP_TYPE_R1B;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Wait for SD card to enter Transfer State */
do {
arg = (sdrca << 16) & 0xFFFF0000;
cmd = SD_CMD_CMD13_SEND_STATUS | SD_CMD_CMD_TYPE_NORMAL |
SD_CMD_DP_NO_DATA_PRESENT | SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE |
SD_CMD_RSP_TYPE_R1;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
} while ((resp[0] & SD_RSP10_R1_CURRENT_STATE) != SD_RSP10_R1_CURRENT_STATE_TRANSFER);
}
/* Set the block length in bytes and the number of blocks to write to the SD card */
MMCHS0_REG(SD_BLK) = SD_BLKSIZE | ( blkcount << 16);
/* Send CMD25, that is write the number of blocks specified in 'blkcount' from 'buf' to the
* location that is 512 byte aligned in the SD card specified by the block number 'blknum'
*/
arg = blknum;
cmd = SD_CMD_CMD25_WRITE_MULTIPLE_BLOCK | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R1 | SD_CMD_MSBS_MULTIPLE |
SD_CMD_DDIR_WRITE | SD_CMD_ACEN_CMD12_ENABLE | SD_CMD_BCE_ENABLE;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Write the data */
do {
/* Wait until data is ready to be written */
while (!(MMCHS0_REG(SD_STAT) & (SD_STAT_BWR | SD_STAT_TC)));
if (MMCHS0_REG(SD_STAT) & SD_STAT_TC)
break;
/* Clear the BWR status bit in SD_STAT */
MMCHS0_REG(SD_STAT) |= SD_STAT_BWR;
for (byteindex = 0; byteindex < (SD_BLKSIZE / 4); byteindex++)
MMCHS0_REG(SD_DATA) = *wordptr++;
} while (!(MMCHS0_REG(SD_STAT) & SD_STAT_TC));
/* Put the SD card into Stand-by State */
arg = 0x00000000;
cmd = SD_CMD_CMD7_SELECT_DESELECT_CARD | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_NO_RESPONSE;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
/* Wait for SD card to enter Stand-by State */
do {
arg= (sdrca << 16) & 0xFFFF0000;
cmd = SD_CMD_CMD13_SEND_STATUS | SD_CMD_CMD_TYPE_NORMAL | SD_CMD_DP_NO_DATA_PRESENT |
SD_CMD_CICE_ENABLE | SD_CMD_CCCE_ENABLE | SD_CMD_RSP_TYPE_R1;
if (sdcmd(cmd, arg, resp) == -1)
return(-1);
} while ((resp[0] & SD_RSP10_R1_CURRENT_STATE) != SD_RSP10_R1_CURRENT_STATE_STANDBY);
return(0);
}
int
sdInstalled(int interface)
{
if ((MMCHS0_REG(SD_CON) & SD_CON_CDP) == SD_CON_CDP_ACTIVE_HIGH)
if (MMCHS0_REG(SD_PSTATE) & SD_PSTATE_CINS)
return(1);
else
return(0);
else
if (MMCHS0_REG(SD_PSTATE) & SD_PSTATE_CINS)
return(0);
else
return(1);
}
int
sdPowerup(int tot)
{
return(-1);
}
int
sdReadCxD(int interface, unsigned char *buf, int cmd)
{
return(-1);
}
