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/crc7.py

@@ -30,7 +30,51 @@
 import time
 import uctypes
 from errno import ETIMEDOUT, EIO, ENODEV, EINVAL
-from crc7 import crc7
+
+crc7_be_syndrome_table = (
+    b"\x00\x12$6HZl~\x90\x82\xb4\xa6\xd8\xca\xfc\xee2 \x16\x04zh^L\xa2\xb0\x86\x94\xea\xf8"
+    b"\xce\xdcdv@R,>\x08\x1a\xf4\xe6\xd0\xc2\xbc\xae\x98\x8aVDr`\x1e\x0c:(\xc6\xd4\xe2\xf0"
+    b"\x8e\x9c\xaa\xb8\xc8\xda\xec\xfe\x80\x92\xa4\xb6XJ|n\x10\x024&\xfa\xe8\xde\xcc\xb2\xa0"
+    b'\x96\x84jxN\\"0\x06\x14\xac\xbe\x88\x9a\xe4\xf6\xc0\xd2<.\x18\ntfPB\x9e\x8c\xba\xa8'
+    b"\xd6\xc4\xf2\xe0\x0e\x1c*8FTbp\x82\x90\xa6\xb4\xca\xd8\xee\xfc\x12\x006$ZH~l\xb0\xa2"
+    b"\x94\x86\xf8\xea\xdc\xce 2\x04\x16hzL^\xe6\xf4\xc2\xd0\xae\xbc\x8a\x98vdR@>,\x1a\x08"
+    b"\xd4\xc6\xf0\xe2\x9c\x8e\xb8\xaaDV`r\x0c\x1e(:JXn|\x02\x10&4\xda\xc8\xfe\xec\x92\x80"
+    b'\xb6\xa4xj\\N0"\x14\x06\xe8\xfa\xcc\xde\xa0\xb2\x84\x96.<\n\x18ftBP\xbe\xac\x9a\x88\xf6'
+    b"\xe4\xd2\xc0\x1c\x0e8*TFpb\x8c\x9e\xa8\xba\xc4\xd6\xe0\xf2"
+)
+
+# ruff: noqa: F821 - @asm_thumb and @viper decorator adds names to function scope
+try:
+    from uctypes import addressof
+
+    @micropython.viper
+    def crc7(buf) -> int:
+        n = int(len(buf))
+        table = ptr8(addressof(crc7_be_syndrome_table))
+        bp = ptr8(addressof(buf))
+        idx = 0
+        crc = 0
+        while idx < n:
+            crc = table[crc ^ bp[idx]]
+            idx = idx + 1
+        return crc
+
+    # test to make sure this works!
+    # print(f"{crc7('abcde'):02x}")
+    assert crc7(b"abcde") == 0x34
+except:
+    # non-viper version if viper can'r be built
+    def crc7(buf) -> int:
+        crc = 0
+        for b in buf:
+            crc = crc7_be_syndrome_table[crc ^ b]
+        return crc
+
+
+def gb(bigval, b0, bn):
+    # get numbered bits from a buf_to_int from, for example, the CSD
+    return (bigval >> b0) & ((1 << (1 + bn - b0)) - 1)
+
 
 _CMD_TIMEOUT = const(50)
 
@@ -64,8 +108,9 @@ def __init__(self, spi, cs, baudrate=1320000, crc16_function=None):
     def check_crcs(self, crc16_function):
         self.crc16 = crc16_function
         result = self.cmd(
-            59, 1 if crc16_function else 0, None, release=True
+            59, 1 if crc16_function else 0, release=True
         )  # send CRC enable/disable command
+        return result
 
     def init_spi(self, baudrate):
         try:
@@ -77,12 +122,7 @@ def init_spi(self, baudrate):
             # on pyboard
             self.spi.init(master, baudrate=baudrate, phase=0, polarity=0)
 
-    @staticmethod
-    def gb(bigval, b0, bn):
-        # get numbered bits from a buf_to_int from, for example, the CSD
-        return (bigval >> b0) & ((1 << (1 + bn - b0)) - 1)
-
-    def spiff(self):
+    def _spiff(self):
         self.spi.write(b"\xff")
 
     def init_card(self, baudrate):
@@ -104,40 +144,40 @@ def init_card(self, baudrate):
             raise OSError(ENODEV, "no SD card")
 
         # CMD8: determine card version
-        r = self.cmd(8, 0x01AA, 0x87, 4)  # probe version
+        r = self.cmd(8, 0x01AA, 4)  # probe version
         v2 = r == _R1_IDLE_STATE
         v1 = r == (_R1_IDLE_STATE | _R1_ILLEGAL_COMMAND)
 
         if not (v1 or v2):
             raise OSError(EIO, "couldn't determine SD card version")
         arg41 = _HCS_BIT if v2 else 0  # we support high capacity, on v2 cards
         for i in range(_CMD_TIMEOUT):  # loop on acmd41 to get
-            self.cmd(55, 0, None)
-            if (r := self.cmd(41, arg41, None)) == 0:
+            self.cmd(55, 0)
+            if (r := self.cmd(41, arg41)) == 0:
                 break
             time.sleep_ms(5)
         if r != 0:
             raise OSError(ETIMEDOUT, "card type", "v2" if v2 else "v1")
 
         # get the number of sectors
         # CMD9: response R2 (R1 byte + 16-byte block read)
-        if self.cmd(9, 0, None, 0, False) != 0:
+        if self.cmd(9, 0, 0, False) != 0:
             raise OSError(EIO, "no CSD response")
         csd = bytearray(16)
         self.readinto(csd)
         self.CSD = csd_int = int.from_bytes(
             csd, "big"
         )  # convert 16-byte CSD to a giant integer for bit extraction
-        gb = self.gb  # just for shorter code
+        _gb = gb  # just for local binding
         # use bit numbers from SD card spec v9.0.0, table 5.3.2
-        vers = gb(csd_int, 126, 127)
+        vers = _gb(csd_int, 126, 127)
         if vers == 1:  # CSD version 2.0
-            self.sectors = (gb(csd_int, 48, 69) + 1) * 1024
+            self.sectors = (_gb(csd_int, 48, 69) + 1) * 1024
             self.cdv = 1
         elif vers == 0x00:  # CSD version 1.0 (old, <=2GB)
-            c_size = gb(csd_int, 62, 73)
-            c_size_mult = gb(csd_int, 47, 49)
-            read_bl_len = gb(csd_int, 80, 83)
+            c_size = _gb(csd_int, 62, 73)
+            c_size_mult = _gb(csd_int, 47, 49)
+            read_bl_len = _gb(csd_int, 80, 83)
             capacity = (c_size + 1) * (2 ** (c_size_mult + 2)) * (2**read_bl_len)
             self.sectors = capacity // 512
             self.cdv = 512  # converts bytes to sectors
@@ -146,18 +186,18 @@ def init_card(self, baudrate):
         # print('sectors', self.sectors)
 
         # CMD16: set block length to 512 bytes
-        if self.cmd(16, 512, None) != 0:
+        if self.cmd(16, 512) != 0:
             raise OSError(EIO, "can't set 512 block size")
 
         # set to high data rate now that it's initialised
         self.init_spi(baudrate)
 
-    def cmd(self, cmd, arg, crc, final=0, release=True, skip1=False):
+    def cmd(self, cmd, arg, final=0, release=True, skip1=False):
         cs = self.cs  # prebind
         w = self.spi.write
         r = self.spi.readinto
         tb = self.tokenbuf
-        spiff = self.spiff
+        spiff = self._spiff
 
         cs(0)  # select chip
 
@@ -168,7 +208,7 @@ def cmd(self, cmd, arg, crc, final=0, release=True, skip1=False):
         buf[2] = arg >> 16
         buf[3] = arg >> 8
         buf[4] = arg
-        buf[5] = (crc if crc is not None else crc7(self.cmdbuf5)) | 1
+        buf[5] = crc7(self.cmdbuf5) | 1
         w(buf)
 
         if skip1:
@@ -207,7 +247,7 @@ def cmd(self, cmd, arg, crc, final=0, release=True, skip1=False):
 
     def readinto(self, buf):
         cs = self.cs
-        spiff = self.spiff
+        spiff = self._spiff
 
         cs(0)
 
@@ -237,7 +277,7 @@ def readinto(self, buf):
 
     def write(self, token, buf):
         cs = self.cs
-        spiff = self.spiff
+        spiff = self._spiff
         r = self.spi.read
         w = self.spi.write
 
@@ -269,13 +309,13 @@ def write(self, token, buf):
     def write_token(self, token):
         self.cs(0)
         self.spi.read(1, token)
-        self.spiff()
+        self._spiff()
         # wait for write to finish
         while self.spi.read(1, 0xFF)[0] == 0x00:
             pass
 
         self.cs(1)
-        self.spiff()
+        self._spiff()
 
     @staticmethod
     def blocks(buf):
@@ -287,29 +327,29 @@ def blocks(buf):
     def readblocks(self, block_num, buf):
         # workaround for shared bus, required for (at least) some Kingston
         # devices, ensure MOSI is high before starting transaction
-        self.spiff()
+        self._spiff()
         nblocks = self.blocks(buf)
 
         # CMD18: set read address for multiple blocks
-        if self.cmd(18, block_num * self.cdv, None, release=False) != 0:
+        if self.cmd(18, block_num * self.cdv, release=False) != 0:
             # release the card
             self.cs(1)
             raise OSError(EIO)  # EIO
         mv = memoryview(buf)
         for offset in range(0, nblocks * 512, 512):
             self.readinto(mv[offset : offset + 512])
 
-        if self.cmd(12, 0, None, skip1=True):
+        if self.cmd(12, 0, skip1=True):
             raise OSError(EIO)  # EIO
 
     def writeblocks(self, block_num, buf):
         # workaround for shared bus, required for (at least) some Kingston
         # devices, ensure MOSI is high before starting transaction
-        self.spiff()
+        self._spiff()
         nblocks = self.blocks(buf)
 
         # CMD25: set write address for first block
-        if (r := self.cmd(25, block_num * self.cdv, None)) != 0:
+        if self.cmd(25, block_num * self.cdv) != 0:
             raise OSError(EIO)  # EIO`
         # send the data
         mv = memoryview(buf)