drivers/sdcard/sdcard.py: Fixes per PR discussion.

Merged crc7.py into sdcard.py, fixed many little things per suggestions.
Removed hardwired crcs from cmd, always recompute.

Signed-off-by: Marcus Mendenhall <mendenmh@gmail.com>

Author: mendenm

micropython/drivers/storage/sdcard/crc16.py

@@ -0,0 +1,111 @@
+import micropython
+from uctypes import addressof
+
+# ruff: noqa: F821 - @asm_thumb and @viper decorator adds names to function scope
+
+# https://electronics.stackexchange.com/questions/321304/how-to-use-the-data-crc-of-sd-cards-in-spi-mode
+# for sd bit mode
+import array
+
+_sd_crc16_table = array.array("H", (0 for _ in range(256)))
+# /* Generate CRC16 table */
+# for (byt = 0U; byt < 256U; byt ++){
+#  crc = byt << 8;
+#  for (bit = 0U; bit < 8U; bit ++){
+#   crc <<= 1;
+#   if ((crc & 0x10000U) != 0U){ crc ^= 0x1021U; }
+#  }
+#  sd_crc16_table[byt] = (crc & 0xFFFFU);
+# }
+for byt in range(256):
+    crc = byt << 8
+    for bit in range(8):
+        crc = crc << 1
+        if (crc & 0x10000) != 0:
+            crc ^= 0x1021
+    _sd_crc16_table[byt] = crc & 0xFFFF
+
+
+# /* Running CRC16 calculation for a byte. */
+# static unsigned int sd_crc16_byte(unsigned int crcval, unsigned int byte)
+# {
+#  return (sd_crc16_table[(byte ^ (crcval >> 8)) & 0xFFU] ^ (crcval << 8)) & 0xFFFFU;
+# }
+
+
+@micropython.viper
+def crc16_viper(crc: int, data) -> int:
+    dp = ptr8(addressof(data))
+    tp = ptr16(addressof(_sd_crc16_table))
+    nn = int(len(data))
+    idx = 0
+    while idx < nn:
+        crc = ((crc << 8) & 0xFFFF) ^ tp[((crc >> 8) ^ dp[idx]) & 0xFF]
+        idx += 1
+    return crc
+
+
+try:  # if we have asm_thumb, this goes faster
+
+    @micropython.asm_thumb
+    def _crc_loop_16(r0, r1, r2, r3) -> int:
+        # r0 is data  address
+        # r1 is table address
+        # r2 is CRC
+        # r3 is count
+        mov(r4, 0)
+        mvn(r4, r4)  # all ones now
+        mov(r7, 16)
+        lsr(r4, r7)  # R4 = half-word of ones
+        mov(r5, 0xFF)  # used for byte masking
+        label(loop)
+        mov(r6, r2)  # copy current CRC
+        mov(r7, 8)
+        lsr(r6, r7)  # crc >> 8
+        ldrb(r7, [r0, 0])  # fetch new byte dp[idx]
+        add(r0, 1)  # push to next byte address
+        eor(r6, r7)  # r6 = (crc>>8) ^ dp[idx]
+        and_(r6, r5)  # mask byte ( (crc>>8) ^ dp[idx]) & 0xff
+        add(r6, r6, r6)  # double for table offset
+        add(r6, r6, r1)  # table data address
+        ldrh(r6, [r6, 0])  # fetch table syndrome
+        mov(r7, 8)
+        lsl(r2, r7)  # CRC << 8
+        and_(r2, r4)  # (crc << 8) & 0xffff)
+        eor(r2, r6)  # new CRC
+        sub(r3, 1)
+        bne(loop)
+        mov(r0, r2)
+
+    @micropython.viper
+    def crc16(crc: int, data) -> int:
+        return int(
+            _crc_loop_16(
+                int(addressof(data)),
+                int(addressof(_sd_crc16_table)),
+                crc,
+                int(len(data)),
+            )
+        )
+
+except:
+    # wrapper to allow the pure-python implementation to be accessed by the right name if asm_thumb doesn't work
+    @micropython.viper
+    def crc16(crc: int, data) -> int:
+        return int(crc16_viper(crc, data))
+
+
+# def test_speed():
+#     data = b"\xaa"*1024
+#     import time
+#     crc = 0
+#     start = time.ticks_us()
+#     for i in range(1024):
+#         crc = crc16(crc, data)
+#     print("asm crc speed = ", f"{crc:08x}", 2**20 / (time.ticks_diff(time.ticks_us(), start) / 1e6), "bytes/s")
+#
+#     crc = 0
+#     start = time.ticks_us()
+#     for i in range(1024):
+#         crc = crc16_viper(crc, data)
+#     print("py  crc speed = ", f"{crc:08x}", 2**20 / (time.ticks_diff(time.ticks_us(), start) / 1e6), "bytes/s")

micropython/drivers/storage/sdcard/manifest.py

@@ -1,3 +1,3 @@
-metadata(description="SDCard block device driver.", version="0.1.0")
+metadata(description="SDCard block device driver.", version="0.2.0")
 
 module("sdcard.py", opt=3)

micropython/drivers/storage/sdcard/sd_card_spi_test.py

@@ -0,0 +1,101 @@
+# SD card setup
+
+from machine import SPI, Pin, freq
+
+freq(120_000_000)
+print("freq:", freq())
+
+import os
+from sdcard import SDCard
+import time
+
+# the bus spi1 on these  pins on my test card
+
+# I have cs on GP13 for this one
+spi = SPI(1, 24_000_000, sck=Pin(14), mosi=Pin(15), miso=Pin(12))
+spi.init()  # Ensure right baudrate
+
+from crc16 import crc16
+
+sd = SDCard(spi=spi, cs=Pin(13, Pin.OUT), baudrate=24_000_000, crc16_function=None)
+vfs = os.VfsFat(sd)
+os.mount(vfs, "/fc")
+
+
+def sdtest():
+    print("Filesystem check")
+    print(os.listdir("/fc"))
+
+    line = "abcdefghijklmnopqrstuvwxyz\n"
+    lines = line * 200  # 5400 chars
+    short = "1234567890\n"
+
+    fn = "/fc/rats.txt"
+    print()
+    print("Multiple block read/write")
+    loops = 1000
+    t0 = time.ticks_ms()
+    with open(fn, "w") as f:
+        n = f.write(lines)
+        print(n, "bytes written")
+        n = f.write(short)
+        print(n, "bytes written")
+        for i in range(loops):
+            n = f.write(lines)
+
+    nbytes = loops * len(lines) + len(lines) + len(short)
+    rate = 1000 * nbytes / time.ticks_diff(time.ticks_ms(), t0)
+    print(nbytes, "bytes written at ", rate / 1e6, "MB/s")
+
+    stat = os.stat(fn)
+    filesize = stat[6]
+    total = 0
+    t0 = time.ticks_ms()
+
+    readbuf = bytearray(8192)
+    import uctypes
+
+    with open(fn, "rb") as f:
+        f.readinto(readbuf)
+        big_readback = readbuf[: len(lines)]  # check a big chunk of data
+
+    with open(fn, "rb") as f:
+        while (count := f.readinto(readbuf)) != 0:
+            total += count
+
+    rate = 1000 * total / time.ticks_diff(time.ticks_ms(), t0)
+
+    print("final file size", filesize, "expected", nbytes, "read", total, "rate=", rate / 1e6)
+
+    fn = "/fc/rats1.txt"
+    print()
+    print("Single block read/write")
+    with open(fn, "w") as f:
+        n = f.write(short)  # one block
+        print(n, "bytes written")
+
+    with open(fn, "r") as f:
+        result2 = f.read()
+        print(len(result2), "bytes read")
+
+    print()
+    print("Verifying data read back")
+    success = True
+    if result2 == short:
+        print("Small file Pass")
+    else:
+        print("Small file Fail")
+        success = False
+    if big_readback == lines:
+        print("Big read Pass")
+    else:
+        print("Big readFail")
+        success = False
+
+    print()
+    print("Tests", "passed" if success else "failed")
+
+
+sdtest()
+
+os.umount("/fc")