Commented out old odd-parity lfs_crc table

We've been linking in this now-unused CRC table when we don't
need to be:

           code          stack
  before: 33976           2824
  after:  33856 (-0.4%)   2824 (+0.0%)

The only catch was it's use in lfs_emubd to provide optional checksums
when debugging. But the actual checksum doesn't matter, so this can be
migrated to crc32c.

bd/lfs_emubd.c

@@ -461,57 +461,57 @@ int lfs_emubd_sync(const struct lfs_config *cfg) {
 
 /// Additional extended API for driving test features ///
 
-static int lfs_emubd_rawcrc(const struct lfs_config *cfg,
+static int lfs_emubd_rawcksum(const struct lfs_config *cfg,
-        lfs_block_t block, uint32_t *crc) {
+        lfs_block_t block, uint32_t *cksum) {
     lfs_emubd_t *bd = cfg->context;
 
-    // check if crc is valid
+    // check if block is valid
     LFS_ASSERT(block < cfg->block_count);
 
-    // crc the block
+    // checksum the block
-    uint32_t crc_ = 0xffffffff;
+    uint32_t cksum_ = 0;
     const lfs_emubd_block_t *b = bd->blocks[block];
     if (b) {
-        crc_ = lfs_crc(crc_, b->data, cfg->block_size);
+        cksum_ = lfs_crc32c(cksum_, b->data, cfg->block_size);
     } else {
         uint8_t erase_value = (bd->cfg->erase_value != -1)
                 ? bd->cfg->erase_value
                 : 0;
         for (lfs_size_t i = 0; i < cfg->block_size; i++) {
-            crc_ = lfs_crc(crc_, &erase_value, 1);
+            cksum_ = lfs_crc32c(cksum_, &erase_value, 1);
         }
     }
-    *crc = 0xffffffff ^ crc_;
+    *cksum = cksum_;
 
     return 0;
 }
 
-int lfs_emubd_crc(const struct lfs_config *cfg,
+int lfs_emubd_cksum(const struct lfs_config *cfg,
-        lfs_block_t block, uint32_t *crc) {
+        lfs_block_t block, uint32_t *cksum) {
-    LFS_EMUBD_TRACE("lfs_emubd_crc(%p, %"PRIu32", %p)",
+    LFS_EMUBD_TRACE("lfs_emubd_cksum(%p, %"PRIu32", %p)",
-            (void*)cfg, block, crc);
+            (void*)cfg, block, cksum);
-    int err = lfs_emubd_rawcrc(cfg, block, crc);
+    int err = lfs_emubd_rawcksum(cfg, block, cksum);
-    LFS_EMUBD_TRACE("lfs_emubd_crc -> %d", err);
+    LFS_EMUBD_TRACE("lfs_emubd_cksum -> %d", err);
     return err;
 }
 
-int lfs_emubd_bdcrc(const struct lfs_config *cfg, uint32_t *crc) {
+int lfs_emubd_bdcrc(const struct lfs_config *cfg, uint32_t *cksum) {
-    LFS_EMUBD_TRACE("lfs_emubd_bdcrc(%p, %p)", (void*)cfg, crc);
+    LFS_EMUBD_TRACE("lfs_emubd_bdcksum(%p, %p)", (void*)cfg, cksum);
 
-    uint32_t crc_ = 0xffffffff;
+    uint32_t cksum_ = 0;
     for (lfs_block_t i = 0; i < cfg->block_count; i++) {
-        uint32_t i_crc;
+        uint32_t i_cksum;
-        int err = lfs_emubd_rawcrc(cfg, i, &i_crc);
+        int err = lfs_emubd_rawcksum(cfg, i, &i_cksum);
         if (err) {
-            LFS_EMUBD_TRACE("lfs_emubd_bdcrc -> %d", err);
+            LFS_EMUBD_TRACE("lfs_emubd_bdcksum -> %d", err);
             return err;
         }
 
-        crc_ = lfs_crc(crc_, &i_crc, sizeof(uint32_t));
+        cksum_ = lfs_crc32c(cksum_, &i_cksum, sizeof(uint32_t));
     }
-    *crc = 0xffffffff ^ crc_;
+    *cksum = cksum_;
 
-    LFS_EMUBD_TRACE("lfs_emubd_bdcrc -> %d", 0);
+    LFS_EMUBD_TRACE("lfs_emubd_bdcksum -> %d", 0);
     return 0;
 }
 

bd/lfs_emubd.h

@@ -179,12 +179,12 @@ int lfs_emubd_sync(const struct lfs_config *cfg);
 
 /// Additional extended API for driving test features ///
 
-// A CRC of a block for debugging purposes
+// A checksum of a block for debugging purposes
-int lfs_emubd_crc(const struct lfs_config *cfg,
+int lfs_emubd_cksum(const struct lfs_config *cfg,
-        lfs_block_t block, uint32_t *crc);
+        lfs_block_t block, uint32_t *cksum);
 
-// A CRC of the entire block device for debugging purposes
+// A checksum of the entire block device for debugging purposes
-int lfs_emubd_bdcrc(const struct lfs_config *cfg, uint32_t *crc);
+int lfs_emubd_bdcksum(const struct lfs_config *cfg, uint32_t *cksum);
 
 // Get total amount of bytes read
 lfs_emubd_sio_t lfs_emubd_readed(const struct lfs_config *cfg);

lfs_util.c

@@ -55,24 +55,24 @@ ssize_t lfs_fromleb128(uint32_t *word, const void *buffer, size_t size) {
 }
 
 
-// Software CRC implementation with small lookup table
+//// Software CRC implementation with small lookup table
-uint32_t lfs_crc(uint32_t crc, const void *buffer, size_t size) {
+//uint32_t lfs_crc(uint32_t crc, const void *buffer, size_t size) {
-    static const uint32_t rtable[16] = {
+//    static const uint32_t rtable[16] = {
-        0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
+//        0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
-        0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
+//        0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
-        0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
+//        0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
-        0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c,
+//        0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c,
-    };
+//    };
-
+//
-    const uint8_t *data = buffer;
+//    const uint8_t *data = buffer;
-
+//
-    for (size_t i = 0; i < size; i++) {
+//    for (size_t i = 0; i < size; i++) {
-        crc = (crc >> 4) ^ rtable[(crc ^ (data[i] >> 0)) & 0xf];
+//        crc = (crc >> 4) ^ rtable[(crc ^ (data[i] >> 0)) & 0xf];
-        crc = (crc >> 4) ^ rtable[(crc ^ (data[i] >> 4)) & 0xf];
+//        crc = (crc >> 4) ^ rtable[(crc ^ (data[i] >> 4)) & 0xf];
-    }
+//    }
-
+//
-    return crc;
+//    return crc;
-}
+//}
 
 // Calculate crc32c incrementally
 uint32_t lfs_crc32c(uint32_t crc, const void *buffer, size_t size) {

lfs_util.h

@@ -359,8 +359,8 @@ ssize_t lfs_fromleb128(uint32_t *word, const void *buffer, size_t size);
 
 
 
-// Calculate CRC-32 with polynomial = 0x04c11db7
+//// Calculate CRC-32 with polynomial = 0x04c11db7
-uint32_t lfs_crc(uint32_t crc, const void *buffer, size_t size);
+//uint32_t lfs_crc(uint32_t crc, const void *buffer, size_t size);
 
 // Calculate crc32c incrementally
 //