modify astyle

Author: rogeryou

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

@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (c) 2022 Macronix International Co., Ltd.
  * SPDX-License-Identifier: Apache-2.0
  */

storage/blockdevice/COMPONENT_SPINAND/source/bch.c

@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (c) 2022 Macronix International Co., Ltd.
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -45,10 +45,11 @@ void bch_encode(struct bch_code *bch, unsigned char *data, unsigned int *ecc)
     unsigned int *p;
     unsigned int *c[16];
     unsigned int *t[16];
-    
+
     t[0] = bch->mod_tab;
-    for (i = 1; i < 16; i++)
+    for (i = 1; i < 16; i++) {
         t[i] = t[i-1] + 4 * (bch->ecc_words);
+    }
 
     memset(bch->ecc, 0, bch->ecc_words * sizeof(*bch->ecc));
 
@@ -79,7 +80,7 @@ void bch_encode(struct bch_code *bch, unsigned char *data, unsigned int *ecc)
             }
         }
         bch->ecc[i] = c[0][i];
-          for (j = 1; j < 16; j++) {
+        for (j = 1; j < 16; j++) {
             bch->ecc[i] ^= c[j][i];
         }
     }
@@ -88,7 +89,7 @@ void bch_encode(struct bch_code *bch, unsigned char *data, unsigned int *ecc)
         for (i = 0; i < bch->ecc_words; i++) {
             ecc[i] = bch->ecc[i];
         }
-    }  
+    }
 }
 
 static inline int mod(struct bch_code *bch, unsigned int v)
@@ -105,7 +106,7 @@ static void build_syndrome(struct bch_code *bch)
     unsigned int i, j;
     unsigned int ecc_bits;
     unsigned int *ecc;
-    
+
     memset(bch->syn, 0, 2 * bch->t * sizeof(*bch->syn));
 
     ecc_bits = bch->ecc_bits;
@@ -115,8 +116,9 @@ static void build_syndrome(struct bch_code *bch)
         ecc_bits = i;
         while (*ecc) {
             if (*ecc & (unsigned int)1) {
-              for (j = 0; j < 2*bch->t; j++)
-                  bch->syn[j] ^= bch->a_pow[mod(bch, (j+1)*i)];
+                for (j = 0; j < 2*bch->t; j++) {
+                    bch->syn[j] ^= bch->a_pow[mod(bch, (j+1)*i)];
+                }
             }
             *ecc >>= 1;
             i++;
@@ -141,21 +143,21 @@ static int build_error_location_poly(struct bch_code *bch)
 
     for (i = 0; (i < bch->t) && (deg <= bch->t); i++) {
         if (d) {
-            k = 2 * i-pp;
+            k = 2 * i - pp;
             if (buf_deg + k > deg) {
                 tmp_deg = deg;
                 for (j = 0; j <= deg; j++) {
                     bch->buf2[j] = bch->elp[j];
                 }
             }
             tmp = bch->n + bch->a_log[d] - bch->a_log[dp];
-                  
+
             for (j = 0; j <= buf_deg; j++) {
                 if (bch->buf[j]) {
-                    bch->elp[j+k] ^= bch->a_pow[mod(bch, tmp + bch->a_log[bch->buf[j]])];
+                    bch->elp[j + k] ^= bch->a_pow[mod(bch, tmp + bch->a_log[bch->buf[j]])];
                 }
             }
-            if (buf_deg+k > deg) {
+            if (buf_deg + k > deg) {
                 deg = buf_deg + k;
                 buf_deg = tmp_deg;
                 for (j = 0; j <= tmp_deg; j++) {
@@ -183,8 +185,8 @@ static int chien_search(struct bch_code *bch, unsigned int deg)
 {
     unsigned int i, j, k, nroot = 0;
     unsigned int syn, syn0;
-    int *rep  = (int*) bch->buf;
-    int *root = (int*) bch->buf2;
+    int *rep  = (int *)bch->buf;
+    int *root = (int *)bch->buf2;
 
     k = bch->n - bch->a_log[bch->elp[deg]];
     for (i = 0; i < deg; i++) {
@@ -205,31 +207,32 @@ static int chien_search(struct bch_code *bch, unsigned int deg)
                 return nroot;
             }
         }
-      }
-  return 0;
+    }
+    return 0;
 }
 
 int bch_decode(struct bch_code *bch, unsigned char *data, unsigned int *ecc)
 {
     unsigned int nbits;
     unsigned int i, err, nroot;
-    int *root = (int*) bch->buf2;
+    int *root = (int *)bch->buf2;
 
     bch_encode(bch, data, NULL);
 
     for (i = 0, err = 0; i < bch->ecc_words; i++) {
         bch->ecc[i] ^= ecc[i];
         err |= bch->ecc[i];
     }
-    if (!err) 
+    if (!err) {
         return 0;
+    }
 
     build_syndrome(bch);
     err = build_error_location_poly(bch);
     if (err <= 0) {
         return -1;
     }
-    
+
     nroot = chien_search(bch, err);
     if (err != nroot) {
         return -1;
@@ -238,7 +241,7 @@ int bch_decode(struct bch_code *bch, unsigned char *data, unsigned int *ecc)
     for (i = 0; i < err; i++) {
         root[i] = nbits - 1 - root[i];
         root[i] = (root[i] & ~7) | (7 - (root[i] & 7));
-        data[root[i]/8] ^= 1 << root[i]%8;
+        data[root[i] / 8] ^= 1 << root[i] % 8;
     }
 
     return err;
@@ -251,7 +254,7 @@ static void build_gf_table(struct bch_code *bch)
     unsigned int prim_poly[5] = {0x11d, 0x211, 0x409, 0x805, 0x1053};
 
     poly = prim_poly[bch->m - 8];
-    msb = 1 << bch->m;  
+    msb = 1 << bch->m;
     bch->a_pow[0] = 1;
     bch->a_log[1] = 0;
     x = 2;
@@ -278,12 +281,12 @@ static void build_mod_tables(struct bch_code *bch, const unsigned int *g)
 
     for (i = 0; i < 4; i++) {
         for (b = 0; b < 16; b++) {
-            tab = bch->mod_tab + (b*4+i)*bch->ecc_words;
-            data = i << (2*b);
+            tab = bch->mod_tab + (b * 4 + i) * bch->ecc_words;
+            data = i << (2 * b);
             while (data) {
                 d = 0;
                 poly = (data >> 1);
-                while(poly) {
+                while (poly) {
                     poly >>= 1;
                     d++;
                 }
@@ -301,10 +304,12 @@ static void build_mod_tables(struct bch_code *bch, const unsigned int *g)
 static void *bch_alloc(size_t size, int *err)
 {
     void *ptr = NULL;
-    if (*err == 0)
+    if (*err == 0) {
         ptr = malloc(size);
-    if (ptr == NULL)
+    }
+    if (ptr == NULL) {
         *err = 1;
+    }
     return ptr;
 }
 
@@ -324,36 +329,38 @@ static unsigned int *build_generator_poly(struct bch_code *bch)
         free(g);
         free(x);
         bch_free(bch);
-          return NULL;
+        return NULL;
     }
-    
+
     bch->ecc_bits = 0;
     x[0] = 1;
     for (t = 0; t < bch->t; t++) {
         for (m = 0, i = 2 * t + 1; m < bch->m; m++) {
             x[bch->ecc_bits + 1] = 1;
             for (j = bch->ecc_bits; j > 0; j--) {
-                if (x[j]) { 
+                if (x[j]) {
                     x[j] = bch->a_pow[mod(bch, bch->a_log[x[j]] + i)] ^ x[j - 1];
                 } else {
-                    x[j] = x[j-1];
+                    x[j] = x[j - 1];
                 }
             }
-            if (x[j])
+            if (x[j]) {
                 x[j] = bch->a_pow[mod(bch, bch->a_log[x[j]] + i)];
+            }
             bch->ecc_bits++;
             i = mod(bch, 2 * i);
         }
     }
 
     i = 0;
     memset(g, 0, (bch->ecc_words + 1) * sizeof(*g));
-    
+
     for (k = bch->ecc_bits + 1; k > 0; k = k - n) {
         n = (k > 32) ? 32 : k;
         for (j = 0; j < n; j++) {
-            if (x[k-1-j])
+            if (x[k - 1 - j]) {
                 g[i] |= (unsigned int)1 << (31 - j);
+            }
         }
         i++;
     }
@@ -380,17 +387,17 @@ struct bch_code *bch_init(unsigned int m, unsigned int t)
 
     bch = (struct bch_code *)malloc(sizeof(struct bch_code));
 
-    if (bch == NULL) { 
+    if (bch == NULL) {
         return NULL;
     }
 
     bch->m = m;
     bch->t = t;
-    bch->n = (1 << m)-1;
+    bch->n = (1 << m) - 1;
     bch->ecc_words  = (m * t + 31) / 32;
     bch->len        = (bch->n + 1) / 8;
-    bch->a_pow      = bch_alloc((1 + bch->n)*sizeof(*bch->a_pow), &err);
-    bch->a_log      = bch_alloc((1 + bch->n)*sizeof(*bch->a_log), &err);
+    bch->a_pow      = bch_alloc((1 + bch->n) * sizeof(*bch->a_pow), &err);
+    bch->a_log      = bch_alloc((1 + bch->n) * sizeof(*bch->a_log), &err);
     bch->mod_tab    = bch_alloc(bch->ecc_words * 16 * 4 * sizeof(*bch->mod_tab), &err);
     bch->ecc        = bch_alloc(bch->ecc_words * sizeof(*bch->ecc), &err);
     bch->syn        = bch_alloc(2 * t * sizeof(*bch->syn), &err);