SDCard speedup : don't re-calculate CRC table on each cmd, and allow faster SPI data rate

Author: Antonin ENFRUN

adafruit_sdcard.py

@@ -81,6 +81,7 @@ class SDCard:
 
         :param ~busio.SPI spi: The SPI bus
         :param ~digitalio.DigitalInOut cs: The chip select connected to the card
+        :param int freq: The SPI data rate to use after card setup
 
         Example usage:
 
@@ -99,8 +100,8 @@ class SDCard:
             os.listdir('/')
 
         """
-    def __init__(self, spi, cs):
-        # This is the init baudrate. We create a second device for high speed.
+    def __init__(self, spi, cs, freq=1320000):
+        # This is the init baudrate. We create a second device with baudrate=freq for high speed.
         self._spi = spi_device.SPIDevice(spi, cs, baudrate=250000, extra_clocks=8)
 
         self._cmdbuf = bytearray(6)
@@ -109,8 +110,8 @@ def __init__(self, spi, cs):
         # Card is byte addressing, set to 1 if addresses are per block
         self._cdv = 512
 
-        # initialise the card
-        self._init_card()
+        # initialise the card and switch to high speed
+        self._init_card(freq)
 
     def _clock_card(self, cycles=8):
         """
@@ -128,7 +129,7 @@ def _clock_card(self, cycles=8):
             self._spi.spi.write(self._single_byte)
         self._spi.spi.unlock()
 
-    def _init_card(self):
+    def _init_card(self, freq):
         """Initialize the card in SPI mode."""
         # clock card at least cycles with cs high
         self._clock_card(80)
@@ -174,7 +175,7 @@ def _init_card(self):
 
         # set to high data rate now that it's initialised
         self._spi = spi_device.SPIDevice(self._spi.spi, self._spi.chip_select,
-                                         baudrate=1320000, extra_clocks=8)
+                                         baudrate=freq, extra_clocks=8)
 
     def _init_card_v1(self):
         """Initialize v1 SDCards which use byte addressing."""
@@ -210,7 +211,7 @@ def _wait_for_ready(self, spi, timeout=0.3):
         :param float timeout: Maximum time to wait in seconds.
         """
         start_time = time.monotonic()
-        self._single_byte[0] = 0x00
+        spi.readinto(self._single_byte, write_value=0xff)
         while time.monotonic() - start_time < timeout and self._single_byte[0] != 0xff:
             spi.readinto(self._single_byte, write_value=0xff)
 
@@ -253,6 +254,7 @@ def _cmd(self, cmd, arg=0, crc=0, response_buf=None, data_block=True, wait=True)
                     if response_buf:
                         if data_block:
                             # Wait for the start block byte
+                            spi.readinto(buf, start=1, end=2, write_value=0xff)
                             while buf[1] != 0xfe:
                                 spi.readinto(buf, start=1, end=2, write_value=0xff)
                         spi.readinto(response_buf, write_value=0xff)
@@ -341,7 +343,7 @@ def _readinto(self, buf, start=0, end=None):
             end = len(buf)
         with self._spi as spi:
             # read until start byte (0xfe)
-            buf[start] = 0xff #busy
+            spi.readinto(buf, start=start, end=start+1, write_value=0xff)
             while buf[start] != 0xfe:
                 spi.readinto(buf, start=start, end=start+1, write_value=0xff)
 
@@ -456,17 +458,13 @@ def writeblocks(self, start_block, buf):
             self._cmd_nodata(_TOKEN_STOP_TRAN, 0x0)
         return 0
 
-def calculate_crc(message):
-    """
-    Calculate the CRC of a message.
-    :param bytearray message: Where each index is a byte
-    """
+def _calculate_crc_table():
+    """Precompute the table used in calculate_crc."""
     # Code converted from https://github.com/hazelnusse/crc7/blob/master/crc7.cc by devoh747
     # With permission from Dale Lukas Peterson <[email protected]>
     # 8/6/2019
 
     crc_table = bytearray(256)
-
     crc_poly = const(0x89)  # the value of our CRC-7 polynomial
 
     # generate a table value for all 256 possible byte values
@@ -479,10 +477,19 @@ def calculate_crc(message):
             crc_table[i] = crc_table[i] << 1
             if (crc_table[i] & 0x80):
                 crc_table[i] = crc_table[i] ^ crc_poly
+    return crc_table
+
+CRC_TABLE = _calculate_crc_table()
+
+def calculate_crc(message):
+    """
+    Calculate the CRC of message[0:5], using a precomputed table in CRC_TABLE.
+    :param bytearray message: Where each index is a byte
+    """
 
     crc = 0
     # All messages in _cmd are 5 bytes including the cmd.. The 6th byte is the crc value.
     for i in range(0, 5):
-        crc = crc_table[(crc << 1) ^ message[i]]
+        crc = CRC_TABLE[(crc << 1) ^ message[i]]
 
     return ((crc << 1) | 1)