update BCH code and lic

Author: rogeryou

storage/blockdevice/COMPONENT_SPINAND/include/SPINAND/SPINANDBlockDevice.h

@@ -20,6 +20,7 @@
 #include "drivers/QSPI.h"
 #include "blockdevice/BlockDevice.h"
 #include "platform/Callback.h"
+#include "bch.h"
 
 #ifndef MBED_CONF_SPINAND_QSPI_IO0
 #define MBED_CONF_SPINAND_QSPI_IO0 NC
@@ -356,9 +357,9 @@ class SPINANDBlockDevice : public mbed::BlockDevice {
     uint8_t _continuous_read;
 
     struct nand_bch_control {
-        struct bch_control   *bch;
-        unsigned int         *errloc;
-        unsigned char        *eccmask;
+        struct bch_code *bch;
+        unsigned int    *errloc;
+        unsigned char   *eccmask;
     };
     struct nand_bch_control _nbc;
 };

storage/blockdevice/COMPONENT_SPINAND/include/SPINAND/bch.h

@@ -1,110 +1,43 @@
 /*
- * Generic binary BCH encoding/decoding library
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc., 51
- * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Copyright © 2011 Parrot S.A.
- *
- * Author: Ivan Djelic <[email protected]>
- *
- * Description:
- *
- * This library provides runtime configurable encoding/decoding of binary
- * Bose-Chaudhuri-Hocquenghem (BCH) codes.
-*/
-/* mbed Microcontroller Library
- * Copyright (c) 2022 ARM Limited
+ * Copyright (c) 2022 Macronix International Co., Ltd.
  * SPDX-License-Identifier: Apache-2.0
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
  */
+
 #ifndef _BCH_H
 #define _BCH_H
 #ifdef __cplusplus
 extern "C" {
 #endif
 #include <stdint.h>
-//typedef unsigned char   uint8_t;
-//typedef unsigned short  uint16_t;
-//typedef unsigned int    uint32_t;
 
 #define DIV_ROUND_UP(n, d)  (((n) + (d) - 1) / (d))
-#define ARRAY_SIZE(arr)     (sizeof(arr) / sizeof((arr)[0]))
-/**
- * struct bch_control - BCH control structure
- * @m:          Galois field order
- * @n:          maximum codeword size in bits (= 2^m-1)
- * @t:          error correction capability in bits
- * @ecc_bits:   ecc exact size in bits, i.e. generator polynomial degree (<=m*t)
- * @ecc_bytes:  ecc max size (m*t bits) in bytes
- * @a_pow_tab:  Galois field GF(2^m) exponentiation lookup table
- * @a_log_tab:  Galois field GF(2^m) log lookup table
- * @mod8_tab:   remainder generator polynomial lookup tables
- * @ecc_buf:    ecc parity words buffer
- * @ecc_buf2:   ecc parity words buffer
- * @xi_tab:     GF(2^m) base for solving degree 2 polynomial roots
- * @syn:        syndrome buffer
- * @cache:      log-based polynomial representation buffer
- * @elp:        error locator polynomial
- * @poly_2t:    temporary polynomials of degree 2t
- */
-struct bch_control {
+
+struct bch_code {
     unsigned int    m;
     unsigned int    n;
     unsigned int    t;
     unsigned int    ecc_bits;
-    unsigned int    ecc_bytes;
-    /* private: */
-    uint16_t       *a_pow_tab;
-    uint16_t       *a_log_tab;
-    uint32_t       *mod8_tab;
-    uint32_t       *ecc_buf;
-    uint32_t       *ecc_buf2;
-    unsigned int   *xi_tab;
+    unsigned int    ecc_words;
+    unsigned int    len;
+    unsigned int   *a_pow;
+    unsigned int   *a_log;
+    unsigned int   *mod_tab;
+    unsigned int   *ecc;
     unsigned int   *syn;
-    int            *cache;
-    struct gf_poly *elp;
-    struct gf_poly *poly_2t[4];
+    unsigned int   *elp;
+    unsigned int   *buf;
+    unsigned int   *buf2;
+    unsigned char   *input_data;
+    unsigned int   endian;
 };
 
-struct bch_control *init_bch(int m, int t, unsigned int prim_poly);
-
-void free_bch(struct bch_control *bch);
-
-void encode_bch(struct bch_control *bch, const uint8_t *data,
-                unsigned int len, uint8_t *ecc);
-
-int decode_bch(struct bch_control *bch, const uint8_t *data, unsigned int len,
-               const uint8_t *recv_ecc, const uint8_t *calc_ecc,
-               const unsigned int *syn, unsigned int *errloc);
+struct bch_code *bch_init(unsigned int m, unsigned int t);
+void bch_free(struct bch_code *bch);
+void bch_encode(struct bch_code *bch, unsigned char *data, unsigned int *ecc);
+int bch_decode(struct bch_code *bch, unsigned char *data, unsigned int *ecc);
 int fls(int x);
-#ifdef _X86_
-#define cpu_to_be32(x)  ((((x)&0xff)<<24) | (((x)&0xff00)<<8) | (((x)>>8)&0xff00) | (((x)>>24)&0xff))
-#else
-#define cpu_to_be32(x)  x
-#endif
+
 #ifdef __cplusplus
 }
 #endif
-#endif /* _BCH_H */
+#endif

storage/blockdevice/COMPONENT_SPINAND/source/SPINANDBlockDevice.cpp

@@ -343,23 +343,22 @@ int SPINANDBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size)
                 goto exit_point;
             }
 
-            // calculate the software ECC
-            for (uint8_t i = 0; ecc_steps; ecc_steps--, i += _ecc_bytes, p += _ecc_size) {
-                _bch_calculate_ecc(p, _ecc_calc + i);
-            }
-
             memcpy(_ecc_code, _page_buf + _page_size + _ecc_layout_pos, _ecc_bytes * _ecc_steps);
 
             p = (uint8_t *)_page_buf;
             ecc_steps = _ecc_steps;
             for (uint8_t i = 0 ; ecc_steps; ecc_steps--, i += _ecc_bytes, p += _ecc_size) {
-                int res = _bch_correct_data(p, _ecc_code + i, _ecc_calc + i);
+                memset(_nbc.bch->input_data, 0x0, (1 << _nbc.bch->m) / 8);
+                memcpy(_nbc.bch->input_data + _ecc_bytes, p, _ecc_size);
+
+                int res = bch_decode(_nbc.bch, _nbc.bch->input_data, (unsigned int *)(_ecc_code + i));
                 if (res < 0) {
                     tr_error("Reading data failed");
                     status = SPINAND_BD_ERROR_DEVICE_ERROR;
                     read_failed = true;
                     goto exit_point;
                 }
+                memcpy(p, _nbc.bch->input_data + _ecc_bytes, _ecc_size);
             }
             memcpy(buffer, _page_buf + offset, read_bytes);
         }
@@ -431,7 +430,9 @@ int SPINANDBlockDevice::program(const void *buffer, bd_addr_t addr, bd_size_t si
 
             // calculate the software ECC
             for (uint8_t i = 0; ecc_steps; ecc_steps--, i += _ecc_bytes, p += _ecc_size) {
-                _bch_calculate_ecc(p, _ecc_calc + i);
+                memset(_nbc.bch->input_data, 0x0, (1 << _nbc.bch->m) / 8);
+                memcpy(_nbc.bch->input_data + _ecc_bytes, p, _ecc_size);
+                _bch_calculate_ecc(_nbc.bch->input_data, _ecc_calc + i);
             }
 
             // prepare ECC code
@@ -532,7 +533,7 @@ bool SPINANDBlockDevice::is_bad_block(uint16_t blk_idx)
 {
     mbed::bd_addr_t addr;
     uint8_t mark[2];
-    
+
     addr = (blk_idx << _block_shift) + _page_size;
     if (QSPI_STATUS_OK != _read_oob(mark, addr, sizeof(mark))) {
         tr_error("Read Command failed");
@@ -547,8 +548,8 @@ int SPINANDBlockDevice::mark_bad_block(uint16_t blk_idx)
     mbed::bd_addr_t addr;
     uint8_t mark[2];
 
-    mark[0] = 0x00; 
-    mark[1] = 0x00; 
+    mark[0] = 0x00;
+    mark[1] = 0x00;
     addr = (blk_idx << _block_shift) + _page_size;
     if (QSPI_STATUS_OK != _program_oob(mark, addr, sizeof(mark))) {
         tr_error("Program Command failed");
@@ -707,6 +708,12 @@ bool SPINANDBlockDevice::_read_otp_onfi()
         _ecc_bits = onfi_table[112];
         if (_ecc_bits > 0) {
             _bch_init(_ecc_bits);
+            secur_reg &= ~SPINAND_SECURE_BIT_ECC_EN;
+
+            if (QSPI_STATUS_OK != _qspi_send_general_command(SPINAND_INST_SET_FEATURE, FEATURES_ADDR_SECURE_OTP,
+                                                             (char *) &secur_reg, 1, NULL, 0)) {
+                tr_error("Writing Register failed");
+            }
         } else {
             secur_reg |= SPINAND_SECURE_BIT_ECC_EN;
 
@@ -768,7 +775,7 @@ int SPINANDBlockDevice::_program_oob(const void *buffer, bd_addr_t addr, bd_size
     int status = SPINAND_BD_ERROR_OK;
 
     _mutex.lock();
-  
+
     //Send WREN
     if (_set_write_enable() != 0) {
         tr_error("Write Enable failed");
@@ -892,7 +899,7 @@ int SPINANDBlockDevice::_set_write_enable()
 
 int SPINANDBlockDevice::_set_conti_read_enable()
 {
-    uint8_t secur_reg = 0;uint8_t secur_reg1 = 0;
+    uint8_t secur_reg = 0;
 
     if (false == _is_mem_ready()) {
         tr_error("Device not ready, set quad enable failed");
@@ -918,10 +925,6 @@ int SPINANDBlockDevice::_set_conti_read_enable()
         tr_error("Device not ready, set quad enable failed");
         return -1;
     }
-    if (QSPI_STATUS_OK != _qspi_send_general_command(SPINAND_INST_GET_FEATURE, FEATURES_ADDR_SECURE_OTP,
-                                                     NULL, 0, (char *) &secur_reg1, 1)) {
-        tr_error("Reading Security Register failed");
-    }
 
     return 0;
 }
@@ -1249,26 +1252,26 @@ void SPINANDBlockDevice::_bch_init(uint8_t ecc_bits)
 {
     unsigned int m, t, i;
     unsigned char *erased_page;
-    unsigned int eccsize = 512;
+    unsigned int eccsize = 410;
     unsigned int eccbytes = 0;
 
-    _ecc_bytes = eccbytes = DIV_ROUND_UP(ecc_bits * fls(8 * eccsize), 8);
+    m = fls(1 + 8 * eccsize);
+    t = ecc_bits;
+
+    _ecc_bytes = eccbytes = ((m * t + 31) / 32) * 4;
     _ecc_size = eccsize;
     _ecc_steps = _page_size / eccsize;
     _ecc_layout_pos = 2; // skip the bad block mark for Macronix spi nand
 
-    m = fls(1 + 8 * eccsize);
-    t = (eccbytes * 8) / m;
-
-    _nbc.bch = init_bch(m, t, 0);
+    _nbc.bch = bch_init(m, t);
     if (!_nbc.bch) {
         return;
     }
 
     /* verify that eccbytes has the expected value */
-    if (_nbc.bch->ecc_bytes != eccbytes) {
+    if (_nbc.bch->ecc_words * 4 != eccbytes) {
         tr_error("invalid eccbytes %u, should be %u\n",
-                 eccbytes, _nbc.bch->ecc_bytes);
+                 eccbytes, _nbc.bch->ecc_words);
         return;
     }
 
@@ -1290,7 +1293,7 @@ void SPINANDBlockDevice::_bch_init(uint8_t ecc_bits)
     memset(_page_buf, 0xff, _page_size + _oob_size);
     memset(erased_page, 0xff, eccsize);
     memset(_nbc.eccmask, 0, eccbytes);
-    encode_bch(_nbc.bch, erased_page, eccsize, _nbc.eccmask);
+    bch_encode(_nbc.bch, erased_page, (unsigned int *)_nbc.eccmask);
     free(erased_page);
 
     for (i = 0; i < eccbytes; i++) {
@@ -1300,7 +1303,7 @@ void SPINANDBlockDevice::_bch_init(uint8_t ecc_bits)
 
 void SPINANDBlockDevice::_bch_free()
 {
-    free_bch(_nbc.bch);
+    bch_free(_nbc.bch);
     free(_nbc.errloc);
     free(_nbc.eccmask);
     free(_page_buf);
@@ -1310,42 +1313,11 @@ void SPINANDBlockDevice::_bch_free()
 
 int SPINANDBlockDevice::_bch_calculate_ecc(unsigned char *buf, unsigned char *code)
 {
-    unsigned int i;
 
     memset(code, 0, _ecc_bytes);
 
-    encode_bch(_nbc.bch, buf, _ecc_size, code);
-
-    /* apply mask so that an erased page is a valid codeword */
-    for (i = 0; i < _ecc_bytes; i++) {
-        code[i] ^= _nbc.eccmask[i];
-    }
+    bch_encode(_nbc.bch, buf, (unsigned int *)code);
 
     return 0;
 }
 
-int SPINANDBlockDevice::_bch_correct_data(unsigned char *buf, unsigned char *read_ecc, unsigned char *calc_ecc)
-{
-    unsigned int *errloc = _nbc.errloc;
-    int i, count;
-
-    count = decode_bch(_nbc.bch, NULL, _ecc_size, read_ecc, calc_ecc,
-                       NULL, errloc);
-    if (count > 0) {
-        for (i = 0; i < count; i++) {
-            if (errloc[i] < (_ecc_size * 8)) {
-                /* error is located in data, correct it */
-                buf[(errloc[i] >> 3) ^ 3] ^= (1 << (errloc[i] & 7));
-            }
-
-            /* else error in ecc, no action needed */
-            tr_error("corrected bitflip %04x:%d\n", (errloc[i] >> 3) ^ 3, errloc[i] & 7);
-        }
-    } else if (count < 0) {
-        tr_error("ecc unrecoverable error\n");
-        count = -EBADMSG;
-    }
-    return count;
-}
-
-