crypto: lib/gf128mul - Remove some bbe deadcode

gf128mul_4k_bbe(), gf128mul_bbe() and gf128mul_init_4k_bbe()
are part of the library originally added in 2006 by
commit c494e0705d67 ("[CRYPTO] lib: table driven multiplications in
GF(2^128)")

but have never been used.

Remove them.
(BBE is Big endian Byte/Big endian bits
Note the 64k table version is used and I've left that in)

Signed-off-by: Dr. David Alan Gilbert <linux@treblig.org>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/include/crypto/gf128mul.h b/include/crypto/gf128mul.h
index 81330c6446f6a0086f83cd9c62897d0ce8e7b8c7..b0853f7cada0cfbffa9c0a3e8e3da7549a209ca6 100644 (file)
--- a/include/crypto/gf128mul.h
+++ b/include/crypto/gf128mul.h
@@ -158,12 +158,10 @@
     64...71 72...79 80...87 88...95  96..103 104.111 112.119 120.127
 */
 
-/*     A slow generic version of gf_mul, implemented for lle and bbe
+/*     A slow generic version of gf_mul, implemented for lle
  *     It multiplies a and b and puts the result in a */
 void gf128mul_lle(be128 *a, const be128 *b);
 
-void gf128mul_bbe(be128 *a, const be128 *b);
-
 /*
  * The following functions multiply a field element by x in
  * the polynomial field representation.  They use 64-bit word operations
@@ -224,9 +222,7 @@ struct gf128mul_4k {
 };
 
 struct gf128mul_4k *gf128mul_init_4k_lle(const be128 *g);
-struct gf128mul_4k *gf128mul_init_4k_bbe(const be128 *g);
 void gf128mul_4k_lle(be128 *a, const struct gf128mul_4k *t);
-void gf128mul_4k_bbe(be128 *a, const struct gf128mul_4k *t);
 void gf128mul_x8_ble(le128 *r, const le128 *x);
 static inline void gf128mul_free_4k(struct gf128mul_4k *t)
 {

diff --git a/lib/crypto/gf128mul.c b/lib/crypto/gf128mul.c
index 8f8c45e0cdcf283a059e313d2e22b4a6ad9a6e0d..fbe72cb3453a5a9870afed69fdd5c00aa6b246cb 100644 (file)
--- a/lib/crypto/gf128mul.c
+++ b/lib/crypto/gf128mul.c
@@ -225,44 +225,6 @@ void gf128mul_lle(be128 *r, const be128 *b)
 }
 EXPORT_SYMBOL(gf128mul_lle);
 
-void gf128mul_bbe(be128 *r, const be128 *b)
-{
-       be128 p[8];
-       int i;
-
-       p[0] = *r;
-       for (i = 0; i < 7; ++i)
-               gf128mul_x_bbe(&p[i + 1], &p[i]);
-
-       memset(r, 0, sizeof(*r));
-       for (i = 0;;) {
-               u8 ch = ((u8 *)b)[i];
-
-               if (ch & 0x80)
-                       be128_xor(r, r, &p[7]);
-               if (ch & 0x40)
-                       be128_xor(r, r, &p[6]);
-               if (ch & 0x20)
-                       be128_xor(r, r, &p[5]);
-               if (ch & 0x10)
-                       be128_xor(r, r, &p[4]);
-               if (ch & 0x08)
-                       be128_xor(r, r, &p[3]);
-               if (ch & 0x04)
-                       be128_xor(r, r, &p[2]);
-               if (ch & 0x02)
-                       be128_xor(r, r, &p[1]);
-               if (ch & 0x01)
-                       be128_xor(r, r, &p[0]);
-
-               if (++i >= 16)
-                       break;
-
-               gf128mul_x8_bbe(r);
-       }
-}
-EXPORT_SYMBOL(gf128mul_bbe);
-
 /*      This version uses 64k bytes of table space.
     A 16 byte buffer has to be multiplied by a 16 byte key
     value in GF(2^128).  If we consider a GF(2^128) value in
@@ -380,28 +342,6 @@ out:
 }
 EXPORT_SYMBOL(gf128mul_init_4k_lle);
 
-struct gf128mul_4k *gf128mul_init_4k_bbe(const be128 *g)
-{
-       struct gf128mul_4k *t;
-       int j, k;
-
-       t = kzalloc(sizeof(*t), GFP_KERNEL);
-       if (!t)
-               goto out;
-
-       t->t[1] = *g;
-       for (j = 1; j <= 64; j <<= 1)
-               gf128mul_x_bbe(&t->t[j + j], &t->t[j]);
-
-       for (j = 2; j < 256; j += j)
-               for (k = 1; k < j; ++k)
-                       be128_xor(&t->t[j + k], &t->t[j], &t->t[k]);
-
-out:
-       return t;
-}
-EXPORT_SYMBOL(gf128mul_init_4k_bbe);
-
 void gf128mul_4k_lle(be128 *a, const struct gf128mul_4k *t)
 {
        u8 *ap = (u8 *)a;
@@ -417,20 +357,5 @@ void gf128mul_4k_lle(be128 *a, const struct gf128mul_4k *t)
 }
 EXPORT_SYMBOL(gf128mul_4k_lle);
 
-void gf128mul_4k_bbe(be128 *a, const struct gf128mul_4k *t)
-{
-       u8 *ap = (u8 *)a;
-       be128 r[1];
-       int i = 0;
-
-       *r = t->t[ap[0]];
-       while (++i < 16) {
-               gf128mul_x8_bbe(r);
-               be128_xor(r, r, &t->t[ap[i]]);
-       }
-       *a = *r;
-}
-EXPORT_SYMBOL(gf128mul_4k_bbe);
-
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Functions for multiplying elements of GF(2^128)");