Sd *sd = SD_CAST(b);
LOG_INFO("reading from block %ld, offset %d, size %d\n", idx, offset, size);
- if ((sd->r1 = sd_setBlockLen(sd, size)))
+ if (sd->tranfer_len != size)
{
- LOG_ERR("setBlockLen failed: %04X\n", sd->r1);
- return 0;
+ if ((sd->r1 = sd_setBlockLen(sd, size)))
+ {
+ LOG_ERR("setBlockLen failed: %04X\n", sd->r1);
+ return 0;
+ }
+ sd->tranfer_len = size;
}
SD_SELECT(sd);
#define SD_WRITE_SINGLEBLOCK 0x58
#define SD_DATA_ACCEPTED 0x05
-static int sd_writeBlock(KBlock *b, block_idx_t idx, const void *buf)
+static size_t sd_writeDirect(KBlock *b, block_idx_t idx, const void *buf, size_t offset, size_t size)
{
Sd *sd = SD_CAST(b);
KFile *fd = sd->ch;
+ ASSERT(offset == 0);
+ ASSERT(size == SD_DEFAULT_BLOCKLEN);
LOG_INFO("writing block %ld\n", idx);
- if ((sd->r1 = sd_setBlockLen(sd, SD_DEFAULT_BLOCKLEN)))
+ if (sd->tranfer_len != SD_DEFAULT_BLOCKLEN)
{
- LOG_ERR("setBlockLen failed: %04X\n", sd->r1);
- return sd->r1;
+ if ((sd->r1 = sd_setBlockLen(sd, SD_DEFAULT_BLOCKLEN)))
+ {
+ LOG_ERR("setBlockLen failed: %04X\n", sd->r1);
+ return 0;
+ }
+ sd->tranfer_len = SD_DEFAULT_BLOCKLEN;
}
SD_SELECT(sd);
{
LOG_ERR("write single block failed: %04X\n", sd->r1);
sd_select(sd, false);
- return sd->r1;
+ return 0;
}
kfile_putc(SD_STARTTOKEN, fd);
return EOF;
}
- return 0;
+ return SD_DEFAULT_BLOCKLEN;
}
void sd_writeTest(Sd *sd)
for (block_idx_t i = 0; i < sd->b.blk_cnt; i++)
{
- LOG_INFO("writing block %ld: %s\n", i, (sd_writeBlock(&sd->b, i, buf) == 0) ? "OK" : "FAIL");
+ LOG_INFO("writing block %ld: %s\n", i, (sd_writeDirect(&sd->b, i, buf, 0, SD_DEFAULT_BLOCKLEN) == SD_DEFAULT_BLOCKLEN) ? "OK" : "FAIL");
}
}
kputchar('\n');
}
- if (sd_writeBlock(&sd->b, 0, buf) != 0)
+ if (sd_writeDirect(&sd->b, 0, buf, 0, SD_DEFAULT_BLOCKLEN) != SD_DEFAULT_BLOCKLEN)
return false;
memset(buf, 0, sizeof(buf));
return sd->r1;
}
-static int sd_clearerr(KBlock *b)
+static void sd_clearerr(KBlock *b)
{
Sd *sd = SD_CAST(b);
sd->r1 = 0;
- return 0;
}
static const KBlockVTable sd_unbuffered_vt =
{
.readDirect = sd_readDirect,
- .writeBlock = sd_writeBlock,
+ .writeDirect = sd_writeDirect,
.error = sd_error,
.clearerr = sd_clearerr,
static const KBlockVTable sd_buffered_vt =
{
.readDirect = sd_readDirect,
- .writeBlock = sd_writeBlock,
+ .writeDirect = sd_writeDirect,
.readBuf = kblock_swReadBuf,
.writeBuf = kblock_swWriteBuf,
#define SD_SEND_OP_COND 0x41
#define SD_SEND_OP_COND_CRC 0xF9
-#define SD_START_DELAY ms_to_ticks(10)
-#define SD_INIT_TIMEOUT ms_to_ticks(1000)
+#define SD_START_DELAY 10
+#define SD_INIT_TIMEOUT ms_to_ticks(2000)
#define SD_IDLE_RETRIES 4
static bool sd_blockInit(Sd *sd, KFile *ch)
}
sd->r1 = sd_setBlockLen(sd, SD_DEFAULT_BLOCKLEN);
+ sd->tranfer_len = SD_DEFAULT_BLOCKLEN;
if (sd->r1)
{
return true;
}
+#if CPU_CM3_SAM3X8
+
+#include <drv/hsmci_sam3.h>
+
+/* SD commands type argument response */
+ /* class 0 */
+/* This is basically the same command as for MMC with some quirks. */
+#define SD_SEND_RELATIVE_ADDR 3 /* bcr R6 */
+#define SD_SEND_IF_COND 8 /* bcr [11:0] See below R7 */
+#define SD_SWITCH_VOLTAGE 11 /* ac R1 */
+
+ /* class 10 */
+#define SD_SWITCH 6 /* adtc [31:0] See below R1 */
+
+ /* class 5 */
+#define SD_ERASE_WR_BLK_START 32 /* ac [31:0] data addr R1 */
+#define SD_ERASE_WR_BLK_END 33 /* ac [31:0] data addr R1 */
+
+ /* Application commands */
+#define SD_APP_SET_BUS_WIDTH 6 /* ac [1:0] bus width R1 */
+#define SD_APP_SD_STATUS 13 /* adtc R1 */
+#define SD_APP_SEND_NUM_WR_BLKS 22 /* adtc R1 */
+#define SD_APP_OP_COND 41 /* bcr [31:0] OCR R3 */
+#define SD_APP_SEND_SCR 51 /* adtc R1 */
+
+/* OCR bit definitions */
+#define SD_OCR_S18R (1 << 24) /* 1.8V switching request */
+#define SD_ROCR_S18A SD_OCR_S18R /* 1.8V switching accepted by card */
+#define SD_OCR_XPC (1 << 28) /* SDXC power control */
+
+/*
+ * SD_SWITCH argument format:
+ *
+ * [31] Check (0) or switch (1)
+ * [30:24] Reserved (0)
+ * [23:20] Function group 6
+ * [19:16] Function group 5
+ * [15:12] Function group 4
+ * [11:8] Function group 3
+ * [7:4] Function group 2
+ * [3:0] Function group 1
+ */
+
+/*
+ * SD_SEND_IF_COND argument format:
+ *
+ * [31:12] Reserved (0)
+ * [11:8] Host Voltage Supply Flags
+ * [7:0] Check Pattern (0xAA)
+ */
+
+/*
+ * SCR field definitions
+ */
+
+#define SCR_SPEC_VER_0 0 /* Implements system specification 1.0 - 1.01 */
+#define SCR_SPEC_VER_1 1 /* Implements system specification 1.10 */
+#define SCR_SPEC_VER_2 2 /* Implements system specification 2.00-3.0X */
+
+#define UNSTUFF_BITS(resp, start, size) \
+ ({ \
+ const uint32_t __size = size; \
+ const uint32_t __mask = (__size < 32 ? 1 << __size : 0) - 1; \
+ const uint32_t __off = 3 - ((start) / 32); \
+ const uint32_t __shft = (start) & 31; \
+ uint32_t __res; \
+ \
+ __res = resp[__off] >> __shft; \
+ if (__size + __shft > 32) \
+ __res |= resp[__off-1] << ((32 - __shft) % 32); \
+ __res & __mask; \
+ })
+
+
+#define SD_ADDR_TO_RCA(addr) (uint32_t)(((addr) << 16) & 0xFFFF0000)
+
+#define BCD_TO_INT_32BIT(bcd) ((uint32_t )((bcd) & 0xf) * 1 + \
+ (((bcd) >> 4) & 0xf) * 10 + \
+ (((bcd) >> 8) & 0xf) * 100 + \
+ (((bcd) >> 12) & 0xf) * 1000 + \
+ (((bcd) >> 16) & 0xf) * 10000 + \
+ (((bcd) >> 20) & 0xf) * 100000 + \
+ (((bcd) >> 24) & 0xf) * 1000000 + \
+ (((bcd) >> 28) & 0xf) * 10000000) \
+
+LOG_INFOB(
+static void dump(const char *label, uint32_t *r, size_t len)
+{
+ ASSERT(r);
+ kprintf("%s [ ", label);
+ for (size_t i = 0; i < len; i++)
+ kprintf("%lx ", r[i]);
+ kputs("]\n");
+}
+)
+
+
+static int sd_decodeCsd(SDcsd *csd, uint32_t *resp, size_t len)
+{
+ ASSERT(csd);
+ ASSERT(resp);
+ ASSERT(len >= 4);
+
+ csd->structure = UNSTUFF_BITS(resp, 126, 2);
+ csd->ccc = UNSTUFF_BITS(resp, 84, 12);
+
+
+ /*
+ * CSD structure:
+ * - 0:
+ * - Version 1.01-1.10
+ * - Version 2.00/Standard Capacity
+ * - 1:
+ * - Version 2.00/High Capacity
+ * - >1: not defined.
+ */
+
+ if (csd->structure == 0)
+ {
+ // (C_size + 1) x 2^(C_SIZE_MUL+2)
+ csd->blk_num = (1 + UNSTUFF_BITS(resp, 62, 12)) << (UNSTUFF_BITS(resp, 47, 3) + 2);
+
+ csd->read_blk_bits = UNSTUFF_BITS(resp, 80, 4);
+ csd->write_blk_bits = UNSTUFF_BITS(resp, 22, 4);
+
+ csd->blk_len = 1 << csd->read_blk_bits;
+ csd->capacity = csd->blk_num * csd->blk_len;
+
+ csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
+ csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
+
+ csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
+ csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
+
+ if (UNSTUFF_BITS(resp, 46, 1))
+ {
+ csd->erase_size = 1;
+ }
+ else if(csd->write_blk_bits >= 9)
+ {
+ csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1;
+ csd->erase_size <<= csd->write_blk_bits - 9;
+ }
+
+ return 0;
+ }
+ else if (csd->structure == 1)
+ {
+ kprintf("csize %ld\n", UNSTUFF_BITS(resp, 48, 22));
+ csd->capacity = (1 + UNSTUFF_BITS(resp, 48, 22)) << 10;
+
+ csd->write_blk_bits = 9;
+ csd->write_partial = 0;
+ csd->write_misalign = 0;
+
+ csd->read_blk_bits = 9;
+ csd->read_partial = 0;
+ csd->read_misalign = 0;
+
+ csd->erase_size = 1;
+ // the block size if fixed to 512kb
+ csd->blk_len = (1 << csd->write_blk_bits) << 10;
+
+ return 0;
+ }
+ else
+ {
+ kprintf("Unrecognised CSD structure version %d\n", csd->structure);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+void sd_dumpCsd(Sd *sd)
+{
+ ASSERT(sd);
+
+ LOG_INFO("VERSION: %d.0\n", sd->csd.structure ? 2 : 1);
+ LOG_INFO("CARD COMMAND CLASS: %d\n", sd->csd.ccc);
+ LOG_INFO("WRITE BLK LEN BITS: %ld\n", sd->csd.write_blk_bits);
+ LOG_INFO("READ BLK LEN BITS: %ld\n", sd->csd.read_blk_bits);
+ LOG_INFO("ERASE SIZE: %ld\n", sd->csd.erase_size);
+ LOG_INFO("BLK NUM: %ld\n", sd->csd.blk_num);
+ LOG_INFO("BLK LEN: %ld\n", sd->csd.blk_len);
+ LOG_INFO("CAPACITY %ld\n", sd->csd.capacity);
+ LOG_INFO("FLAG Write: WP %d, W MISALIGN %d\n", sd->csd.write_partial, sd->csd.write_misalign);
+ LOG_INFO("FLAG Read: RP %d, R MISALIGN %d\n", sd->csd.read_partial, sd->csd.read_misalign);
+
+}
+
+void sd_dumpCid(Sd *sd)
+{
+ ASSERT(sd);
+
+ LOG_INFO("MANFID: %d\n", sd->cid.manfid);
+ LOG_INFO("OEMID: %d\n", sd->cid.oemid);
+ LOG_INFO("SERIAL: %ld\n", sd->cid.serial);
+ LOG_INFO("PROD_NAME: %s\n", sd->cid.prod_name);
+ LOG_INFO("REV: %d.%d\n", sd->cid.m_rev, sd->cid.l_rev);
+ LOG_INFO("OFF,Y,M: %lx, %ld %ld\n", sd->cid.year_off, (BCD_TO_INT_32BIT(sd->cid.year_off) / 12) + 2000,
+ (BCD_TO_INT_32BIT(sd->cid.year_off) % 12));
+}
+
+void sd_sendInit(void)
+{
+ if (hsmci_sendCmd(0, 0, HSMCI_CMDR_SPCMD_INIT | HSMCI_CMDR_RSPTYP_NORESP))
+ LOG_ERR("INIT: %lx\n", HSMCI_SR);
+}
+
+
+void sd_goIdle(void)
+{
+ if (hsmci_sendCmd(0, 0, HSMCI_CMDR_RSPTYP_NORESP))
+ LOG_ERR("GO_IDLE: %lx\n", HSMCI_SR);
+}
+
+int sd_sendIfCond(void)
+{
+ if (hsmci_sendCmd(8, CMD8_V_RANGE_27V_36V, HSMCI_CMDR_RSPTYP_48_BIT))
+ {
+ LOG_ERR("IF_COND %lx\n", HSMCI_SR);
+ return -1;
+ }
+ else
+ {
+ uint32_t r = HSMCI_RSPR;
+ if ((r & 0xFFF) == CMD8_V_RANGE_27V_36V)
+ {
+ LOG_INFO("IF_COND: %lx\n", r);
+ return 0;
+ }
+ LOG_ERR("IF_COND: %lx\n", r);
+ }
+ return -1;
+}
+
+int sd_sendAppOpCond(void)
+{
+ if (hsmci_sendCmd(55, 0, HSMCI_CMDR_RSPTYP_48_BIT))
+ {
+ LOG_ERR("APP_CMD %lx\n", HSMCI_SR);
+ return -1;
+ }
+ else
+ {
+ LOG_INFO("APP_CMD %lx\n", HSMCI_RSPR);
+ }
+
+ if (hsmci_sendCmd(41, SD_HOST_VOLTAGE_RANGE | SD_OCR_CCS, HSMCI_CMDR_RSPTYP_48_BIT))// se cmd 8 va ok.
+ {
+ LOG_ERR("APP_OP_COND %lx\n", HSMCI_SR);
+ return -1;
+ }
+ else
+ {
+ uint32_t status = HSMCI_RSPR;
+ if (status & SD_OCR_BUSY)
+ {
+ LOG_INFO("SD power up! Hight Capability [%d]\n", (bool)(status & SD_OCR_CCS));
+ return 0;
+ }
+
+ LOG_ERR("sd not ready.\n");
+ }
+
+ return -1;
+}
+
+
+int sd_getCid(Sd *sd, uint32_t addr, uint8_t flag)
+{
+ ASSERT(sd);
+ memset(&(sd->cid), 0, sizeof(SDcid));
+
+ uint8_t idx = 9; // CMD9 get cid from gived sd address (RCA)
+ if (flag & SD_SEND_ALL_CID)
+ idx = 2;
+
+
+ if (hsmci_sendCmd(idx, SD_ADDR_TO_RCA(addr), HSMCI_CMDR_RSPTYP_136_BIT))
+ {
+ LOG_ERR("GET_CID %lx\n", HSMCI_SR);
+ return -1;
+ }
+ else
+ {
+ uint32_t resp[4];
+ hsmci_readResp(resp, 4);
+ LOG_INFOB(dump("CID", resp, 4););
+
+ sd->cid.manfid = UNSTUFF_BITS(resp, 120, 8);
+ sd->cid.oemid = UNSTUFF_BITS(resp, 104, 16);
+ sd->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8);
+ sd->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8);
+ sd->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8);
+ sd->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8);
+ sd->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8);
+ sd->cid.m_rev = UNSTUFF_BITS(resp, 60, 4);
+ sd->cid.l_rev = UNSTUFF_BITS(resp, 56, 4);
+ sd->cid.serial = (uint32_t)UNSTUFF_BITS(resp, 24, 32);
+ sd->cid.year_off = UNSTUFF_BITS(resp, 8, 12);
+ }
+
+ return 0;
+}
+
+int sd_getCsd(Sd *sd)
+{
+ ASSERT(sd);
+ memset(&(sd->csd), 0, sizeof(SDcsd));
+
+ LOG_INFO("Send to RCA: %lx\n", SD_ADDR_TO_RCA(sd->addr));
+ if (hsmci_sendCmd(9, SD_ADDR_TO_RCA(sd->addr), HSMCI_CMDR_RSPTYP_136_BIT))
+ {
+ LOG_ERR("GET_CSD %lx\n", HSMCI_SR);
+ return -1;
+ }
+ else
+ {
+ uint32_t resp[4];
+ hsmci_readResp(resp, 4);
+ LOG_INFOB(dump("CSD", resp, 4););
+ sd_decodeCsd(&(sd->csd), resp, 4);
+ }
+
+ return 0;
+}
+
+int sd_appStatus(Sd *sd)
+{
+ ASSERT(sd);
+ LOG_INFO("Send to RCA: %lx\n", SD_ADDR_TO_RCA(sd->addr));
+ if (hsmci_sendCmd(13, SD_ADDR_TO_RCA(sd->addr), HSMCI_CMDR_RSPTYP_48_BIT))
+ {
+ LOG_ERR("STATUS: %lx\n", HSMCI_SR);
+ return -1;
+ }
+ else
+ {
+ hsmci_readResp(&(sd->status), 1);
+ LOG_INFOB(dump("STATUS", &(sd->status), 1););
+ }
+
+ return 0;
+}
+
+int sd_getRelativeAddr(Sd *sd)
+{
+ ASSERT(sd);
+ if (hsmci_sendCmd(3, 0, HSMCI_CMDR_RSPTYP_48_BIT))
+ {
+ LOG_ERR("RCA: %lx\n", HSMCI_SR);
+ return -1;
+ }
+ else
+ {
+ hsmci_readResp(&sd->addr, 1);
+ LOG_INFOB(dump("RCA", &sd->addr, 1););
+
+ sd->addr = sd->addr >> 16;
+ }
+
+ return 0;
+}
+
+int sd_selectCard(Sd *sd)
+{
+ ASSERT(sd);
+ LOG_INFO("Select RCA: %lx\n", SD_ADDR_TO_RCA(sd->addr));
+ if (hsmci_sendCmd(7, SD_ADDR_TO_RCA(sd->addr), HSMCI_CMDR_RSPTYP_R1B))
+ {
+ LOG_ERR("SELECT_SD: %lx\n", HSMCI_SR);
+ return -1;
+ }
+ else
+ {
+ HSMCI_CHECK_BUSY();
+
+ hsmci_readResp(&(sd->status), 1);
+ LOG_INFOB(dump("SELECT_SD", &(sd->status), 1););
+ }
+
+ return 0;
+}
+
+int sd_setBusWidth(Sd *sd, size_t len)
+{
+ ASSERT(sd);
+
+ if (hsmci_sendCmd(55, 0, HSMCI_CMDR_RSPTYP_48_BIT))
+ {
+ LOG_ERR("APP_CMD %lx\n", HSMCI_SR);
+ return -1;
+ }
+ else
+ {
+ LOG_INFO("APP_CMD %lx\n", HSMCI_RSPR);
+ }
+
+
+ if (hsmci_sendCmd(6, len, HSMCI_CMDR_RSPTYP_48_BIT))
+ {
+ LOG_ERR("SET_BUS_WIDTH: %lx\n", HSMCI_SR);
+ return -1;
+ }
+ else
+ {
+ hsmci_readResp(&(sd->status), 1);
+ LOG_INFOB(dump("SET_BUS_WIDTH", &(sd->status), 1););
+
+ HSMCI_CHECK_BUSY();
+ }
+
+ return 0;
+}
+
+
+int sd_set_BlockLen(Sd *sd, size_t len)
+{
+ ASSERT(sd);
+
+ if (hsmci_sendCmd(16, len, HSMCI_CMDR_RSPTYP_48_BIT))
+ {
+ LOG_ERR("SET_BUS_WIDTH: %lx\n", HSMCI_SR);
+ return -1;
+ }
+ else
+ {
+ hsmci_readResp(&(sd->status), 1);
+ LOG_INFOB(dump("SET_BUS_WIDTH", &(sd->status), 1););
+
+ HSMCI_CHECK_BUSY();
+ }
+
+ return 0;
+}
+
+
+#endif
+
+
bool sd_initUnbuf(Sd *sd, KFile *ch)
{
if (sd_blockInit(sd, ch))
if (sd_blockInit(sd, ch))
{
sd->b.priv.buf = sd_buf;
- sd->b.priv.flags |= KB_BUFFERED;
+ sd->b.priv.flags |= KB_BUFFERED | KB_PARTIAL_WRITE;
sd->b.priv.vt = &sd_buffered_vt;
sd->b.priv.vt->load(&sd->b, 0);
return true;
return false;
}
+
+
projects / bertos.git / blobdiff