Mercurial > nand-ecoscentric

changeset 3390:9b8c245fbdef

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
io/nand include/nand_ecc.h src/nand.c tests/...: Split out ecc init function into init_rd and init_wr for hardware which needs it; create CYG_NAND_ECC_ALG_HW3 to instantiate, and backwards-compatibly fix up the previous instantiation macros.
author Ross Younger <wry@ecoscentric.com>
date Sun, 05 Oct 2014 20:04:07 +1300
parents 1ee7927cc736
children 46870ac5c312
files packages/io/nand/current/ChangeLog packages/io/nand/current/include/nand_ecc.h packages/io/nand/current/src/nand.c packages/io/nand/current/tests/nand_eccequiv.c packages/io/nand/current/tests/nand_sweccwalk.c packages/io/nand/current/tests/nandunit.c
diffstat 6 files changed, 32 insertions(+), 20 deletions(-) [+]
line wrap: on
line diff
--- a/packages/io/nand/current/ChangeLog
+++ b/packages/io/nand/current/ChangeLog
@@ -2,6 +2,11 @@ 2014-10-05  Ross Younger  <wry@ecoscentr
 
 	* include/nand.h: Create CYG_NAND_BYTES_PER_BLOCK so this
 	computation need only be coded in one place.
+	* include/nand_ecc.h src/nand.c
+	tests/nand_eccequiv.c tests/nand_sweccwalk.c tests/nandunit.c:
+	Split out ecc init function into init_rd and init_wr for hardware
+	which needs it; create CYG_NAND_ECC_ALG_HW3 to instantiate, and
+	backwards-compatibly fix up the previous instantiation macros.
 
 2014-09-27  Ross Younger  <wry@ecoscentric.com>
 	* cdl/nand.cdl src/nand.c tests/nand_readlimits.c
--- a/packages/io/nand/current/include/nand_ecc.h
+++ b/packages/io/nand/current/include/nand_ecc.h
@@ -69,8 +69,10 @@ typedef struct {
     const unsigned  data_size;
     /* How many ECC bytes does this algorithm use per data block? */
     const unsigned  ecc_size;
-    /* Initialises an ECC computation. May be NULL if not required. */
-    void (*init)(struct _cyg_nand_device_t *dev);
+    /* Initialises an ECC computation on read. May be NULL if not required. */
+    void (*init_rd)(struct _cyg_nand_device_t *dev);
+    /* Initialises an ECC computation on write. May be NULL if not required. */
+    void (*init_wr)(struct _cyg_nand_device_t *dev);
 
     /* These two functions return the ECC for the given data block.
      * calc_rd is called on read, calc_wr on write; normally they are
@@ -105,11 +107,12 @@ typedef struct {
                   CYG_BYTE *ecc_read, const CYG_BYTE *ecc_calc);
 } cyg_nand_ecc_t;
 
-#define CYG_NAND_ECC_ALG(_name, _dataz, _eccz, _init, _calc_rd, _calc_wr, _repair, _flags)  \
+#define CYG_NAND_ECC_ALG(_name, _dataz, _eccz, _init_rd, _init_wr, _calc_rd, _calc_wr, _repair, _flags)  \
     cyg_nand_ecc_t _name = {                                           \
         .data_size = _dataz,                                           \
         .ecc_size = _eccz,                                             \
-        .init = _init,                                                 \
+        .init_rd = _init_rd,                                           \
+        .init_wr = _init_wr,                                           \
         .calc_rd = _calc_rd,                                           \
         .calc_wr = _calc_wr,                                           \
         .repair = _repair,                                             \
@@ -117,14 +120,18 @@ typedef struct {
     }
 
 #define CYG_NAND_ECC_ALG_SW(_name, _dataz, _eccz, _init, _calc, _repair) \
-    CYG_NAND_ECC_ALG(_name, _dataz, _eccz, _init, _calc, _calc, _repair, 0)
+    CYG_NAND_ECC_ALG(_name, _dataz, _eccz, _init, _init, _calc, _calc, _repair, 0)
 
 #define CYG_NAND_ECC_ALG_HW(_name, _dataz, _eccz, _init, _calc, _repair) \
-    CYG_NAND_ECC_ALG(_name, _dataz, _eccz, _init, _calc, _calc, _repair, \
+    CYG_NAND_ECC_ALG(_name, _dataz, _eccz, _init, _init, _calc, _calc, _repair, \
             NAND_ECC_FLAG_IS_HARDWARE)
 
 #define CYG_NAND_ECC_ALG_HW2(_name, _dataz, _eccz, _init, _calc_rd, _calc_wr, _repair) \
-    CYG_NAND_ECC_ALG(_name, _dataz, _eccz, _init, _calc_rd, _calc_wr,   \
+    CYG_NAND_ECC_ALG(_name, _dataz, _eccz, _init, _init, _calc_rd, _calc_wr,   \
+            _repair, NAND_ECC_FLAG_IS_HARDWARE)
+
+#define CYG_NAND_ECC_ALG_HW3(_name, _dataz, _eccz, _init_rd, _init_wr, _calc_rd, _calc_wr, _repair) \
+    CYG_NAND_ECC_ALG(_name, _dataz, _eccz, _init_rd, _init_wr, _calc_rd, _calc_wr,   \
             _repair, NAND_ECC_FLAG_IS_HARDWARE)
 
 /* Useful code ==================================================== */
--- a/packages/io/nand/current/src/nand.c
+++ b/packages/io/nand/current/src/nand.c
@@ -454,7 +454,7 @@ int nandi_read_whole_page_raw(cyg_nand_d
                 CYG_ASSERTC(remain >= read_data_stride);
 
                 TIMETAG();
-                if (do_hw_ecc && dev->ecc->init) dev->ecc->init(dev);
+                if (do_hw_ecc && dev->ecc->init_rd) dev->ecc->init_rd(dev);
                 EG(dev->fns->read_stride(dev, data_dest, read_data_stride));
                 TIMETAG();
 
@@ -484,7 +484,7 @@ int nandi_read_whole_page_raw(cyg_nand_d
                     ecc_calc_p = ecc_calc;
 
                     while (remain) {
-                        if (dev->ecc->init) dev->ecc->init(dev);
+                        if (dev->ecc->init_rd) dev->ecc->init_rd(dev);
                         dev->ecc->calc_rd(dev, data_dest, ecc_calc_p);
 
                         remain -= ecc_data_stride;
@@ -616,7 +616,7 @@ int nandi_write_page_raw(cyg_nand_device
 
         while (remain) {
             CYG_ASSERTC(remain >= ecc_data_stride);
-            if (dev->ecc->init) dev->ecc->init(dev);
+            if (dev->ecc->init_wr) dev->ecc->init_wr(dev);
             dev->ecc->calc_wr(dev, data_src, ecc_dest);
 
             remain -= ecc_data_stride;
@@ -633,7 +633,7 @@ int nandi_write_page_raw(cyg_nand_device
         while (remain) {
             CYG_ASSERTC(remain >= write_data_stride);
             TIMETAG();
-            if (do_hw_ecc && dev->ecc->init) dev->ecc->init(dev);
+            if (do_hw_ecc && dev->ecc->init_wr) dev->ecc->init_wr(dev);
             EG(dev->fns->write_stride(dev, src, write_data_stride));
             TIMETAG();
             if (do_hw_ecc) {
@@ -769,8 +769,8 @@ err_exit:
 }
 
 /* Computes the ECC for a whole device page.
- * This is intended for use with software ECC only! (The calc_wr
- * function will be used.)
+ * This is intended for use with software ECC only! (The init_wr
+ * and calc_wr functions will be used.)
  *
  * 'page' points to the data; a whole page will necessarily be read.
  * The computed ECC will be stored in 'ecc_o'; CYG_NAND_ECCPERPAGE(dev)
@@ -784,8 +784,8 @@ void nand_ecci_calc_page(cyg_nand_device
     CYG_CHECK_DATA_PTRC(ecc_o);
 
     for (i=0; i<nblocks; i++) {
-        if (dev->ecc->init)
-            dev->ecc->init(dev);
+        if (dev->ecc->init_wr)
+            dev->ecc->init_wr(dev);
         dev->ecc->calc_wr(dev,page,ecc_o);
         page += dev->ecc->data_size;
         ecc_o += dev->ecc->ecc_size;
--- a/packages/io/nand/current/tests/nand_eccequiv.c
+++ b/packages/io/nand/current/tests/nand_eccequiv.c
@@ -81,8 +81,8 @@ void init_fakenand(void)
 
 void ecc(cyg_nand_device *dev, const CYG_BYTE *data, CYG_BYTE *out)
 {
-    if (dev->ecc->init)
-        dev->ecc->init(dev);
+    if (dev->ecc->init_wr)
+        dev->ecc->init_wr(dev);
     dev->ecc->calc_wr(dev, data, out);
 }
 
--- a/packages/io/nand/current/tests/nand_sweccwalk.c
+++ b/packages/io/nand/current/tests/nand_sweccwalk.c
@@ -73,8 +73,8 @@ void init_fakenand(void)
 
 void ecc(cyg_nand_device *dev, const CYG_BYTE *data, const char *msg, CYG_BYTE *out)
 {
-    if (dev->ecc->init)
-        dev->ecc->init(dev);
+    if (dev->ecc->init_wr)
+        dev->ecc->init_wr(dev);
     dev->ecc->calc_wr(dev, data, out);
     diag_printf("%s: ecc=%02x%02x%02x\n", msg, out[0], out[1], out[2]);
     // TODO adapt this display for ECCs longer than 3 bytes
--- a/packages/io/nand/current/tests/nandunit.c
+++ b/packages/io/nand/current/tests/nandunit.c
@@ -180,7 +180,7 @@ int do_ecc_known_answer(eccvector *v)
     CYG_BYTE *ecc_o = &ecc[0];
 
     for (i=0; i<nblocks; i++) {
-        if (fakenand.ecc->init) fakenand.ecc->init(&fakenand);
+        if (fakenand.ecc->init_wr) fakenand.ecc->init_wr(&fakenand);
         fakenand.ecc->calc_wr(&fakenand, page, ecc_o);
         page += fakenand.ecc->data_size;
         ecc_o += fakenand.ecc->ecc_size;