sdcard driver moved to drv/

2 files changed, 116 insertions, 112 deletions

diff --git a/fw/fe310/eos/dev/sdcard.c b/fw/fe310/eos/dev/drv/sdcard.c
index a2ee598..bc6b999 100644
--- a/fw/fe310/eos/dev/sdcard.c
+++ b/fw/fe310/eos/dev/drv/sdcard.c
@@ -1,16 +1,15 @@
 #include <stdlib.h>
 #include <stdint.h>
-#include <stdio.h>
 
 #include "eos.h"
-#include "soc/timer.h"
-#include "soc/spi.h"
-
-#include "spi.h"
 
-#include "sdc_crypto.h"
+#include "sdc_platform.h"
 #include "sdcard.h"
 
+#ifdef SDC_DEBUG
+#include <stdio.h>
+#endif
+
 #define SDC_TIMEOUT_CMD         500
 #define SDC_TIMEOUT_READ        200
 #define SDC_TIMEOUT_WRITE       500
@@ -44,7 +43,7 @@
 
 #define SDC_NCR                 10
 
-#define SDC_ERR(rv)             ((rv < 0) ? rv : EOS_ERR)
+#define SDC_RV2ERR(rv)          ((rv < 0) ? rv : SDC_ERR)
 
 /* CMD */
 #define GO_IDLE_STATE           0
@@ -95,20 +94,20 @@ static uint16_t sdc_crc16(uint16_t crc, uint8_t b) {
 }
 
 static uint32_t sdc_nto(uint32_t start, uint32_t timeout) {
-    uint32_t d = eos_time_delta_ms(start);
+    uint32_t d = sdc_tdelta_ms(start);
     return (d > timeout) ? 0 : timeout - d;
 }
 
 static uint8_t sdc_xchg8(uint8_t data) {
-    return eos_spi_xchg8(data, 0);
+    return sdc_spi_xchg8(data, 0);
 }
 
 static uint16_t sdc_xchg16(uint16_t data) {
-    return eos_spi_xchg16(data, 0);
+    return sdc_spi_xchg16(data, 0);
 }
 
 static uint32_t sdc_xchg32(uint32_t data) {
-    return eos_spi_xchg32(data, 0);
+    return sdc_spi_xchg32(data, 0);
 }
 
 static void sdc_buf_send(unsigned char *buffer, uint16_t len) {
@@ -128,13 +127,13 @@ static void sdc_buf_recv(unsigned char *buffer, uint16_t len) {
 }
 
 static void sdc_select(void) {
-    eos_spi_cs_set();
-    eos_spi_xchg8(0xff, 0);
+    sdc_spi_cs_set();
+    sdc_spi_xchg8(0xff, 0);
 }
 
 static void sdc_deselect(void) {
-    eos_spi_cs_clear();
-    eos_spi_xchg8(0xff, 0);
+    sdc_spi_cs_clear();
+    sdc_spi_xchg8(0xff, 0);
 }
 
 static int sdc_xchg_cmd(uint8_t cmd, uint32_t arg, uint8_t flags) {
@@ -160,7 +159,7 @@ static int sdc_xchg_cmd(uint8_t cmd, uint32_t arg, uint8_t flags) {
     do {
         ret = sdc_xchg8(0xff);
     } while ((ret & 0x80) && --i);
-    if (ret & 0x80) return EOS_ERR_BUSY;
+    if (ret & 0x80) return SDC_ERR_BUSY;
 
     return ret;
 }
@@ -169,36 +168,36 @@ static int sdc_ready(uint32_t timeout) {
     uint8_t d = 0;
     uint32_t start;
 
-    if (timeout == 0) return EOS_ERR_BUSY;
+    if (timeout == 0) return SDC_ERR_BUSY;
 
-    start = eos_time_get_tick();
+    start = sdc_get_tick();
     do {
-        if (eos_time_delta_ms(start) > timeout) break;
+        if (sdc_tdelta_ms(start) > timeout) break;
         d = sdc_xchg8(0xff);
     } while (d != 0xff);
-    if (d != 0xff) return EOS_ERR_BUSY;
+    if (d != 0xff) return SDC_ERR_BUSY;
 
-    return EOS_OK;
+    return SDC_OK;
 }
 
 static int sdc_block_read(uint8_t *buffer, uint16_t len, uint32_t timeout) {
     uint8_t token = 0xff;
     uint32_t start;
 
-    if (timeout == 0) return EOS_ERR_BUSY;
+    if (timeout == 0) return SDC_ERR_BUSY;
 
-    start = eos_time_get_tick();
+    start = sdc_get_tick();
     do {
-        if (eos_time_delta_ms(start) > timeout) break;
+        if (sdc_tdelta_ms(start) > timeout) break;
         token = sdc_xchg8(0xff);
     } while (token == 0xff);
-    if (token == 0xff) return EOS_ERR_BUSY;
-    if (token != SDC_TOKEN_START_BLK) return EOS_ERR;
+    if (token == 0xff) return SDC_ERR_BUSY;
+    if (token != SDC_TOKEN_START_BLK) return SDC_ERR;
 
     sdc_buf_recv(buffer, len);
     sdc_xchg16(0xffff); /* dummy CRC */
 
-    return EOS_OK;
+    return SDC_OK;
 }
 
 static int sdc_block_write(uint8_t token, uint8_t *buffer, uint16_t len, uint32_t timeout) {
@@ -214,16 +213,16 @@ static int sdc_block_write(uint8_t token, uint8_t *buffer, uint16_t len, uint32_
         sdc_xchg16(0xffff); /* dummy CRC */
 
         d = sdc_xchg8(0xff); /* Response */
-        if ((d & SDC_DRESP_MASK) != SDC_DRESP_ACCEPT) return EOS_ERR;
+        if ((d & SDC_DRESP_MASK) != SDC_DRESP_ACCEPT) return SDC_ERR;
     }
 
-    return EOS_OK;
+    return SDC_OK;
 }
 
 static int sdc_cmd(uint8_t cmd, uint32_t arg, uint8_t flags, uint32_t timeout) {
     int do_cs = !(flags & SDC_CMD_FLAG_NOCS);
     int do_wait = !(flags & SDC_CMD_FLAG_NOWAIT);
-    int rv = EOS_OK;
+    int rv = SDC_OK;
 
     if (do_cs) sdc_select();
     if (do_wait) rv = sdc_ready(timeout);
@@ -240,7 +239,7 @@ static int sdc_acmd(uint8_t cmd, uint32_t arg, uint8_t flags, uint32_t timeout)
     int rv;
     uint32_t start;
 
-    start = eos_time_get_tick();
+    start = sdc_get_tick();
     rv = sdc_cmd(APP_CMD, 0, flags, timeout);
     if (rv & ~SDC_R1_IDLE_STATE) return rv;
 
@@ -251,18 +250,18 @@ static int sdc_acmd(uint8_t cmd, uint32_t arg, uint8_t flags, uint32_t timeout)
     return sdc_cmd(cmd, arg, flags, sdc_nto(start, timeout));
 }
 
-static int sdc_init(uint32_t timeout) {
+int sdc_init(uint32_t timeout) {
     int rv, i;
     uint8_t _type;
     uint8_t ocr[4];
     uint32_t start;
 
-    start = eos_time_get_tick();
-    eos_time_sleep(100);
+    start = sdc_get_tick();
+    sdc_sleep(5);
     for (i=10; i--;) sdc_xchg8(0xff);     /* 80 dummy cycles */
 
     rv = sdc_cmd(GO_IDLE_STATE, 0, SDC_CMD_FLAG_CRC, SDC_TIMEOUT_CMD);
-    if (rv != SDC_R1_IDLE_STATE) return SDC_ERR(rv);
+    if (rv != SDC_R1_IDLE_STATE) return SDC_RV2ERR(rv);
 
     sdc_select();
     rv = sdc_cmd(SEND_IF_COND, 0x1aa, SDC_CMD_FLAG_CRC | SDC_CMD_FLAG_NOCS, sdc_nto(start, timeout));
@@ -276,7 +275,7 @@ static int sdc_init(uint32_t timeout) {
                 do {
                     rv = sdc_acmd(SD_APP_OP_COND, 0x40000000, 0, sdc_nto(start, timeout));
                 } while (rv == SDC_R1_IDLE_STATE);
-                if (rv != SDC_R1_READY) return SDC_ERR(rv);
+                if (rv != SDC_R1_READY) return SDC_RV2ERR(rv);
 
                 sdc_select();
                 rv = sdc_cmd(READ_OCR, 0, SDC_CMD_FLAG_NOCS, sdc_nto(start, timeout));
@@ -287,11 +286,11 @@ static int sdc_init(uint32_t timeout) {
                     sdc_deselect();
                 } else {
                     sdc_deselect();
-                    return SDC_ERR(rv);
+                    return SDC_RV2ERR(rv);
                 }
 
-                _type = EOS_SDC_TYPE_SDC2;
-                if (ocr[0] & 0xc0) _type |= EOS_SDC_CAP_BLK;
+                _type = SDC_TYPE_SDC2;
+                if (ocr[0] & 0xc0) _type |= SDC_CAP_BLK;
             }
             break;
 
@@ -303,17 +302,17 @@ static int sdc_init(uint32_t timeout) {
                     do  {
                         rv = sdc_acmd(SD_APP_OP_COND, 0, 0, sdc_nto(start, timeout));
                     } while (rv == SDC_R1_IDLE_STATE);
-                    if (rv != SDC_R1_READY) return SDC_ERR(rv);
+                    if (rv != SDC_R1_READY) return SDC_RV2ERR(rv);
                 case SDC_R1_READY:
-                    _type = EOS_SDC_TYPE_SDC1;
+                    _type = SDC_TYPE_SDC1;
                     break;
 
                 default:
                     do {
                         rv = sdc_cmd(SEND_OP_COND, 0, 0, sdc_nto(start, timeout));
                     } while (rv == SDC_R1_IDLE_STATE);
-                    if (rv != SDC_R1_READY) return SDC_ERR(rv);
-                    _type = EOS_SDC_TYPE_MMC;
+                    if (rv != SDC_R1_READY) return SDC_RV2ERR(rv);
+                    _type = SDC_TYPE_MMC;
                     break;
 
             }
@@ -321,15 +320,15 @@ static int sdc_init(uint32_t timeout) {
 
         default:
             sdc_deselect();
-            return SDC_ERR(rv);
+            return SDC_RV2ERR(rv);
     }
 
-    if (!(_type & EOS_SDC_CAP_BLK)) {
+    if (!(_type & SDC_CAP_BLK)) {
         rv = sdc_cmd(SET_BLOCKLEN, 512, 0, sdc_nto(start, timeout));
-        if (rv != SDC_R1_READY) return SDC_ERR(rv);
+        if (rv != SDC_R1_READY) return SDC_RV2ERR(rv);
     }
 
-    if (_type & EOS_SDC_TYPE_SDC) {
+    if (_type & SDC_TYPE_SDC) {
         uint8_t csd[16];
 
         sdc_select();
@@ -337,60 +336,65 @@ static int sdc_init(uint32_t timeout) {
         if (rv == SDC_R1_READY) {
             rv = sdc_block_read(csd, 16, sdc_nto(start, timeout));
         } else {
-            rv = SDC_ERR(rv);
+            rv = SDC_RV2ERR(rv);
         }
         sdc_deselect();
         if (rv) return rv;
 
+#ifdef SDC_DEBUG
+        printf("SDCARD CSD: ");
         for (i=0; i<16; i++) {
             printf("%.2x ", csd[i]);
         }
         printf("\n");
-        if (csd[10] & 0x40) _type |= EOS_SDC_CAP_ERASE_EN;
+#endif
+        if (csd[10] & 0x40) _type |= SDC_CAP_ERASE_EN;
     }
 
-    eos_spi_set_div(EOS_SPI_DEV_SDC, 5);
     sdc_type = _type;
-    return EOS_OK;
+    return SDC_OK;
 }
 
-int eos_sdc_init(uint8_t wakeup_cause) {
+#include "board.h"
+#include "spi.h"
+
+int sdc_init(uint8_t wakeup_cause) {
     int rv;
 
-    rv = eos_spi_select(EOS_SPI_DEV_SDC);
-    if (rv) return rv;
+    sdc_spi_set_div(SDC_SPI_DEV_SDC, 1024);     // 100 - 400 kHz
 
-    rv = sdc_init(5000);
-    if (rv) {
-        printf("SDC ERROR\n");
-    } else {
-        printf("SDC OK:%x\n", sdc_type);
-    }
-    eos_spi_deselect();
+    rv = sdc_spi_select(SDC_SPI_DEV_SDC);
+    if (rv) goto sdc_init_fin;
+
+    rv = sdc_init(1000);
+    sdc_spi_deselect();
 
-    return EOS_OK;
+sdc_init_fin:
+    sdc_spi_set_div(SDC_SPI_DEV_SDC, SPI_DIV_SDC);
+
+    return rv;
 }
 
-uint8_t eos_sdc_type(void) {
-    return sdc_type & EOS_SDC_TYPE_MASK;
+uint8_t sdc_get_type(void) {
+    return sdc_type & SDC_TYPE_MASK;
 }
 
-uint8_t eos_sdc_cap(void) {
-    return sdc_type & EOS_SDC_CAP_MASK;
+uint8_t sdc_get_cap(void) {
+    return sdc_type & SDC_CAP_MASK;
 }
 
-int eos_sdc_get_sect_count(uint32_t timeout, uint32_t *sectors) {
+int sdc_get_sect_count(uint32_t timeout, uint32_t *sectors) {
     int rv;
     uint8_t csd[16];
     uint32_t start;
 
-    start = eos_time_get_tick();
+    start = sdc_get_tick();
     sdc_select();
     rv = sdc_cmd(SEND_CSD, 0, SDC_CMD_FLAG_NOCS, timeout);
     if (rv == SDC_R1_READY) {
         rv = sdc_block_read(csd, 16, sdc_nto(start, timeout));
     } else {
-        rv = SDC_ERR(rv);
+        rv = SDC_RV2ERR(rv);
     }
     sdc_deselect();
     if (rv) return rv;
@@ -403,42 +407,42 @@ int eos_sdc_get_sect_count(uint32_t timeout, uint32_t *sectors) {
         *sectors = *sectors << (n - 9);
     }
 
-    return EOS_OK;
+    return SDC_OK;
 }
 
-int eos_sdc_get_blk_size(uint32_t timeout, uint32_t *size) {
+int sdc_get_blk_size(uint32_t timeout, uint32_t *size) {
     int rv;
     uint8_t rbl[64];    /* SD Status or CSD register */
     uint32_t start;
-    
-    start = eos_time_get_tick();
+
+    start = sdc_get_tick();
     sdc_select();
-    if (sdc_type & EOS_SDC_TYPE_SDC2) {
+    if (sdc_type & SDC_TYPE_SDC2) {
         rv = sdc_acmd(SD_STATUS, 0, SDC_CMD_FLAG_NOCS, timeout);
         sdc_xchg8(0xff);    /* R2 response */
     } else {
         rv = sdc_cmd(SEND_CSD, 0, SDC_CMD_FLAG_NOCS, timeout);
     }
     if (rv == SDC_R1_READY) {
-        rv = sdc_block_read(rbl, (sdc_type & EOS_SDC_TYPE_SDC2) ? 64 : 16, sdc_nto(start, timeout));
+        rv = sdc_block_read(rbl, (sdc_type & SDC_TYPE_SDC2) ? 64 : 16, sdc_nto(start, timeout));
     } else {
-        rv = SDC_ERR(rv);
+        rv = SDC_RV2ERR(rv);
     }
     sdc_deselect();
     if (rv) return rv;
 
-    if (sdc_type & EOS_SDC_TYPE_SDC2) {
+    if (sdc_type & SDC_TYPE_SDC2) {
         *size = 16UL << (rbl[10] >> 4);
-    } else if (sdc_type & EOS_SDC_TYPE_SDC1) {
+    } else if (sdc_type & SDC_TYPE_SDC1) {
         *size = (((rbl[10] & 0x3f) << 1) + (rbl[11] >> 7) + 1) << ((rbl[13] >> 6) - 1);
     } else {
         *size = (((rbl[10] & 0x7c) >> 2) + 1) * (((rbl[11] & 0x03) << 3) + (rbl[11] >> 5) + 1);
     }
 
-    return EOS_OK;
+    return SDC_OK;
 }
 
-int eos_sdc_sync(uint32_t timeout) {
+int sdc_sync(uint32_t timeout) {
     int rv;
 
     sdc_select();
@@ -448,35 +452,35 @@ int eos_sdc_sync(uint32_t timeout) {
     return rv;
 }
 
-int eos_sdc_erase(uint32_t blk_start, uint32_t blk_end, uint32_t timeout) {
+int sdc_erase(uint32_t blk_start, uint32_t blk_end, uint32_t timeout) {
     int rv;
     uint32_t start;
 
-    if (!(sdc_type & EOS_SDC_TYPE_SDC)) return EOS_ERR;
-    if (!(sdc_type & EOS_SDC_CAP_ERASE_EN)) return EOS_ERR;
-    if (!(sdc_type & EOS_SDC_CAP_BLK)) {
+    if (!(sdc_type & SDC_TYPE_SDC)) return SDC_ERR;
+    if (!(sdc_type & SDC_CAP_ERASE_EN)) return SDC_ERR;
+    if (!(sdc_type & SDC_CAP_BLK)) {
         blk_start *= 512;
         blk_end *= 512;
     }
 
-    start = eos_time_get_tick();
+    start = sdc_get_tick();
     rv = sdc_cmd(ERASE_WR_BLK_START, blk_start, 0, timeout);
-    if (rv != SDC_R1_READY) return SDC_ERR(rv);
+    if (rv != SDC_R1_READY) return SDC_RV2ERR(rv);
 
     rv = sdc_cmd(ERASE_WR_BLK_END, blk_end, 0, sdc_nto(start, timeout));
-    if (rv != SDC_R1_READY) return SDC_ERR(rv);
+    if (rv != SDC_R1_READY) return SDC_RV2ERR(rv);
 
     rv = sdc_cmd(ERASE, 0, 0, sdc_nto(start, timeout));
-    if (rv != SDC_R1_READY) return SDC_ERR(rv);
+    if (rv != SDC_R1_READY) return SDC_RV2ERR(rv);
 
-    return eos_sdc_sync(sdc_nto(start, timeout));
+    return sdc_sync(sdc_nto(start, timeout));
 }
 
-int eos_sdc_sect_read(uint32_t sect, unsigned int count, uint8_t *buffer) {
+int sdc_sect_read(uint32_t sect, unsigned int count, uint8_t *buffer) {
     int rv;
     uint8_t cmd = ((count == 1) ? READ_SINGLE_BLOCK : READ_MULTIPLE_BLOCK);
 
-    if (!(sdc_type & EOS_SDC_CAP_BLK)) sect *= 512;
+    if (!(sdc_type & SDC_CAP_BLK)) sect *= 512;
 
     sdc_select();
     rv = sdc_cmd(cmd, sect, SDC_CMD_FLAG_NOCS, SDC_TIMEOUT_CMD);
@@ -486,39 +490,39 @@ int eos_sdc_sect_read(uint32_t sect, unsigned int count, uint8_t *buffer) {
         while (count) {
             rv = sdc_block_read(buffer, 512, SDC_TIMEOUT_READ);
             if (rv) break;
-            eos_sdcc_decrypt(sect, buffer);
+            sdc_decrypt(sect, buffer);
             buffer += 512;
             count--;
         }
         if (cmd == READ_MULTIPLE_BLOCK) _rv = sdc_cmd(STOP_TRANSMISSION, 0, SDC_CMD_FLAG_NOCS | SDC_CMD_FLAG_NOWAIT | SDC_CMD_FLAG_RSTUFF, 0);
-        if (!rv && (_rv != SDC_R1_READY)) rv = SDC_ERR(_rv);
+        if (!rv && (_rv != SDC_R1_READY)) rv = SDC_RV2ERR(_rv);
     } else {
-        rv = SDC_ERR(rv);
+        rv = SDC_RV2ERR(rv);
     }
     sdc_deselect();
 
     return rv;
 }
 
-int eos_sdc_sect_write(uint32_t sect, unsigned int count, uint8_t *buffer) {
+int sdc_sect_write(uint32_t sect, unsigned int count, uint8_t *buffer) {
     int rv;
 
-    if (!(sdc_type & EOS_SDC_CAP_BLK)) sect *= 512;
+    if (!(sdc_type & SDC_CAP_BLK)) sect *= 512;
 
     if (count == 1) {
         sdc_select();
         rv = sdc_cmd(WRITE_BLOCK, sect, SDC_CMD_FLAG_NOCS, SDC_TIMEOUT_CMD);
         if (rv == SDC_R1_READY) {
-            eos_sdcc_encrypt(sect, buffer);
+            sdc_encrypt(sect, buffer);
             rv = sdc_block_write(SDC_TOKEN_START_BLK, buffer, 512, SDC_TIMEOUT_WRITE);
         } else {
-            rv = SDC_ERR(rv);
+            rv = SDC_RV2ERR(rv);
         }
         sdc_deselect();
     } else {
-        if (sdc_type & EOS_SDC_TYPE_SDC) {
+        if (sdc_type & SDC_TYPE_SDC) {
             rv = sdc_acmd(SET_WR_BLK_ERASE_COUNT, count, 0, SDC_TIMEOUT_CMD);
-            if (rv != SDC_R1_READY) return SDC_ERR(rv);
+            if (rv != SDC_R1_READY) return SDC_RV2ERR(rv);
         }
 
         sdc_select();
@@ -527,16 +531,16 @@ int eos_sdc_sect_write(uint32_t sect, unsigned int count, uint8_t *buffer) {
             int _rv;
 
             while (count) {
-                eos_sdcc_encrypt(sect, buffer);
+                sdc_encrypt(sect, buffer);
                 rv = sdc_block_write(SDC_TOKEN_START_BLKM, buffer, 512, SDC_TIMEOUT_WRITE);
                 if (rv) break;
                 buffer += 512;
                 count--;
             }
             _rv = sdc_block_write(SDC_TOKEN_STOP_TRAN, NULL, 0, SDC_TIMEOUT_WRITE);
-            if (!rv && (_rv != SDC_R1_READY)) rv = SDC_ERR(_rv);
+            if (!rv && (_rv != SDC_R1_READY)) rv = SDC_RV2ERR(_rv);
         } else {
-            rv = SDC_ERR(rv);
+            rv = SDC_RV2ERR(rv);
         }
         sdc_deselect();
     }
diff --git a/fw/fe310/eos/dev/sdcard.h b/fw/fe310/eos/dev/drv/sdcard.h
index 910a6e0..ec453f4 100644
--- a/fw/fe310/eos/dev/sdcard.h
+++ b/fw/fe310/eos/dev/drv/sdcard.h
@@ -1,17 +1,17 @@
 #include <stdint.h>
 
-#define EOS_SDC_TYPE_MMC            0x01
+#define SDC_TYPE_MMC                0x01
 
-#define EOS_SDC_TYPE_SDC1           0x04
-#define EOS_SDC_TYPE_SDC2           0x08
-#define EOS_SDC_TYPE_SDC            0x0c
-#define EOS_SDC_TYPE_MASK           0x0f
+#define SDC_TYPE_SDC1               0x04
+#define SDC_TYPE_SDC2               0x08
+#define SDC_TYPE_SDC                0x0c
+#define SDC_TYPE_MASK               0x0f
 
-#define EOS_SDC_CAP_BLK             0x10
-#define EOS_SDC_CAP_ERASE_EN        0x20
-#define EOS_SDC_CAP_MASK            0xf0
+#define SDC_CAP_BLK                 0x10
+#define SDC_CAP_ERASE_EN            0x20
+#define SDC_CAP_MASK                0xf0
 
-int eos_sdc_init(uint8_t wakeup_cause);
+int sdc_init(uint32_t timeout);
 uint8_t eos_sdc_type(void);
 uint8_t eos_sdc_cap(void);
 int eos_sdc_get_sect_count(uint32_t timeout, uint32_t *sectors);