staging: skein: cleanup: add operator white space

Added white space between operators and operands. Because this sometimes
maxed out the column width, some expressions were broken up into multiple
lines, and comments were moved appropriately.

Signed-off-by: Manu Kumar <maraku@gmx.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/staging/skein/skein_base.c b/drivers/staging/skein/skein_base.c
index 25a01ca76953bd40d61275d1974a120ff7bbfaf8..3e3485cbff7ba4159f64e48834df480a1d685c37 100644 (file)
--- a/drivers/staging/skein/skein_base.c
+++ b/drivers/staging/skein/skein_base.c
@@ -58,7 +58,7 @@ int skein_256_init(struct skein_256_ctx *ctx, size_t hash_bit_len)
                cfg.w[1] = skein_swap64(hash_bit_len);
                cfg.w[2] = skein_swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL);
                /* zero pad config block */
-               memset(&cfg.w[3], 0, sizeof(cfg) - 3*sizeof(cfg.w[0]));
+               memset(&cfg.w[3], 0, sizeof(cfg) - 3 * sizeof(cfg.w[0]));
 
                /* compute the initial chaining values from config block */
                /* zero the chaining variables */
@@ -98,7 +98,7 @@ int skein_256_init_ext(struct skein_256_ctx *ctx, size_t hash_bit_len,
                skein_assert(sizeof(cfg.b) >= sizeof(ctx->x));
                /* do a mini-Init right here */
                /* set output hash bit count = state size */
-               ctx->h.hash_bit_len = 8*sizeof(ctx->x);
+               ctx->h.hash_bit_len = 8 * sizeof(ctx->x);
                /* set tweaks: T0 = 0; T1 = KEY type */
                skein_start_new_type(ctx, KEY);
                /* zero the initial chaining variables */
@@ -171,7 +171,7 @@ int skein_256_update(struct skein_256_ctx *ctx, const u8 *msg,
                 */
                if (msg_byte_cnt > SKEIN_256_BLOCK_BYTES) {
                        /* number of full blocks to process */
-                       n = (msg_byte_cnt-1) / SKEIN_256_BLOCK_BYTES;
+                       n = (msg_byte_cnt - 1) / SKEIN_256_BLOCK_BYTES;
                        skein_256_process_block(ctx, msg, n,
                                                SKEIN_256_BLOCK_BYTES);
                        msg_byte_cnt -= n * SKEIN_256_BLOCK_BYTES;
@@ -219,19 +219,19 @@ int skein_256_final(struct skein_256_ctx *ctx, u8 *hash_val)
        memset(ctx->b, 0, sizeof(ctx->b));
        /* keep a local copy of counter mode "key" */
        memcpy(x, ctx->x, sizeof(x));
-       for (i = 0; i*SKEIN_256_BLOCK_BYTES < byte_cnt; i++) {
+       for (i = 0; i * SKEIN_256_BLOCK_BYTES < byte_cnt; i++) {
                /* build the counter block */
                ((u64 *)ctx->b)[0] = skein_swap64((u64) i);
                skein_start_new_type(ctx, OUT_FINAL);
                /* run "counter mode" */
                skein_256_process_block(ctx, ctx->b, 1, sizeof(u64));
                /* number of output bytes left to go */
-               n = byte_cnt - i*SKEIN_256_BLOCK_BYTES;
+               n = byte_cnt - i * SKEIN_256_BLOCK_BYTES;
                if (n >= SKEIN_256_BLOCK_BYTES)
                        n  = SKEIN_256_BLOCK_BYTES;
                /* "output" the ctr mode bytes */
-               skein_put64_lsb_first(hash_val+i*SKEIN_256_BLOCK_BYTES, ctx->x,
-                                     n);
+               skein_put64_lsb_first(hash_val + i * SKEIN_256_BLOCK_BYTES,
+                                     ctx->x, n);
                /* restore the counter mode key for next time */
                memcpy(ctx->x, x, sizeof(x));
        }
@@ -282,7 +282,7 @@ int skein_512_init(struct skein_512_ctx *ctx, size_t hash_bit_len)
                cfg.w[1] = skein_swap64(hash_bit_len);
                cfg.w[2] = skein_swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL);
                /* zero pad config block */
-               memset(&cfg.w[3], 0, sizeof(cfg) - 3*sizeof(cfg.w[0]));
+               memset(&cfg.w[3], 0, sizeof(cfg) - 3 * sizeof(cfg.w[0]));
 
                /* compute the initial chaining values from config block */
                /* zero the chaining variables */
@@ -326,7 +326,7 @@ int skein_512_init_ext(struct skein_512_ctx *ctx, size_t hash_bit_len,
                skein_assert(sizeof(cfg.b) >= sizeof(ctx->x));
                /* do a mini-Init right here */
                /* set output hash bit count = state size */
-               ctx->h.hash_bit_len = 8*sizeof(ctx->x);
+               ctx->h.hash_bit_len = 8 * sizeof(ctx->x);
                /* set tweaks: T0 = 0; T1 = KEY type */
                skein_start_new_type(ctx, KEY);
                /* zero the initial chaining variables */
@@ -398,7 +398,7 @@ int skein_512_update(struct skein_512_ctx *ctx, const u8 *msg,
                 */
                if (msg_byte_cnt > SKEIN_512_BLOCK_BYTES) {
                        /* number of full blocks to process */
-                       n = (msg_byte_cnt-1) / SKEIN_512_BLOCK_BYTES;
+                       n = (msg_byte_cnt - 1) / SKEIN_512_BLOCK_BYTES;
                        skein_512_process_block(ctx, msg, n,
                                                SKEIN_512_BLOCK_BYTES);
                        msg_byte_cnt -= n * SKEIN_512_BLOCK_BYTES;
@@ -446,19 +446,19 @@ int skein_512_final(struct skein_512_ctx *ctx, u8 *hash_val)
        memset(ctx->b, 0, sizeof(ctx->b));
        /* keep a local copy of counter mode "key" */
        memcpy(x, ctx->x, sizeof(x));
-       for (i = 0; i*SKEIN_512_BLOCK_BYTES < byte_cnt; i++) {
+       for (i = 0; i * SKEIN_512_BLOCK_BYTES < byte_cnt; i++) {
                /* build the counter block */
                ((u64 *)ctx->b)[0] = skein_swap64((u64) i);
                skein_start_new_type(ctx, OUT_FINAL);
                /* run "counter mode" */
                skein_512_process_block(ctx, ctx->b, 1, sizeof(u64));
                /* number of output bytes left to go */
-               n = byte_cnt - i*SKEIN_512_BLOCK_BYTES;
+               n = byte_cnt - i * SKEIN_512_BLOCK_BYTES;
                if (n >= SKEIN_512_BLOCK_BYTES)
                        n  = SKEIN_512_BLOCK_BYTES;
                /* "output" the ctr mode bytes */
-               skein_put64_lsb_first(hash_val+i*SKEIN_512_BLOCK_BYTES, ctx->x,
-                                     n);
+               skein_put64_lsb_first(hash_val + i * SKEIN_512_BLOCK_BYTES,
+                                     ctx->x, n);
                /* restore the counter mode key for next time */
                memcpy(ctx->x, x, sizeof(x));
        }
@@ -506,7 +506,7 @@ int skein_1024_init(struct skein_1024_ctx *ctx, size_t hash_bit_len)
                cfg.w[1] = skein_swap64(hash_bit_len);
                cfg.w[2] = skein_swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL);
                /* zero pad config block */
-               memset(&cfg.w[3], 0, sizeof(cfg) - 3*sizeof(cfg.w[0]));
+               memset(&cfg.w[3], 0, sizeof(cfg) - 3 * sizeof(cfg.w[0]));
 
                /* compute the initial chaining values from config block */
                /* zero the chaining variables */
@@ -547,7 +547,7 @@ int skein_1024_init_ext(struct skein_1024_ctx *ctx, size_t hash_bit_len,
                skein_assert(sizeof(cfg.b) >= sizeof(ctx->x));
                /* do a mini-Init right here */
                /* set output hash bit count = state size */
-               ctx->h.hash_bit_len = 8*sizeof(ctx->x);
+               ctx->h.hash_bit_len = 8 * sizeof(ctx->x);
                /* set tweaks: T0 = 0; T1 = KEY type */
                skein_start_new_type(ctx, KEY);
                /* zero the initial chaining variables */
@@ -620,7 +620,7 @@ int skein_1024_update(struct skein_1024_ctx *ctx, const u8 *msg,
                 */
                if (msg_byte_cnt > SKEIN_1024_BLOCK_BYTES) {
                        /* number of full blocks to process */
-                       n = (msg_byte_cnt-1) / SKEIN_1024_BLOCK_BYTES;
+                       n = (msg_byte_cnt - 1) / SKEIN_1024_BLOCK_BYTES;
                        skein_1024_process_block(ctx, msg, n,
                                                 SKEIN_1024_BLOCK_BYTES);
                        msg_byte_cnt -= n * SKEIN_1024_BLOCK_BYTES;
@@ -668,19 +668,19 @@ int skein_1024_final(struct skein_1024_ctx *ctx, u8 *hash_val)
        memset(ctx->b, 0, sizeof(ctx->b));
        /* keep a local copy of counter mode "key" */
        memcpy(x, ctx->x, sizeof(x));
-       for (i = 0; i*SKEIN_1024_BLOCK_BYTES < byte_cnt; i++) {
+       for (i = 0; i * SKEIN_1024_BLOCK_BYTES < byte_cnt; i++) {
                /* build the counter block */
                ((u64 *)ctx->b)[0] = skein_swap64((u64) i);
                skein_start_new_type(ctx, OUT_FINAL);
                /* run "counter mode" */
                skein_1024_process_block(ctx, ctx->b, 1, sizeof(u64));
                /* number of output bytes left to go */
-               n = byte_cnt - i*SKEIN_1024_BLOCK_BYTES;
+               n = byte_cnt - i * SKEIN_1024_BLOCK_BYTES;
                if (n >= SKEIN_1024_BLOCK_BYTES)
                        n  = SKEIN_1024_BLOCK_BYTES;
                /* "output" the ctr mode bytes */
-               skein_put64_lsb_first(hash_val+i*SKEIN_1024_BLOCK_BYTES, ctx->x,
-                                     n);
+               skein_put64_lsb_first(hash_val + i * SKEIN_1024_BLOCK_BYTES,
+                                     ctx->x, n);
                /* restore the counter mode key for next time */
                memcpy(ctx->x, x, sizeof(x));
        }
@@ -775,19 +775,19 @@ int skein_256_output(struct skein_256_ctx *ctx, u8 *hash_val)
        memset(ctx->b, 0, sizeof(ctx->b));
        /* keep a local copy of counter mode "key" */
        memcpy(x, ctx->x, sizeof(x));
-       for (i = 0; i*SKEIN_256_BLOCK_BYTES < byte_cnt; i++) {
+       for (i = 0; i * SKEIN_256_BLOCK_BYTES < byte_cnt; i++) {
                /* build the counter block */
                ((u64 *)ctx->b)[0] = skein_swap64((u64) i);
                skein_start_new_type(ctx, OUT_FINAL);
                /* run "counter mode" */
                skein_256_process_block(ctx, ctx->b, 1, sizeof(u64));
                /* number of output bytes left to go */
-               n = byte_cnt - i*SKEIN_256_BLOCK_BYTES;
+               n = byte_cnt - i * SKEIN_256_BLOCK_BYTES;
                if (n >= SKEIN_256_BLOCK_BYTES)
                        n  = SKEIN_256_BLOCK_BYTES;
                /* "output" the ctr mode bytes */
-               skein_put64_lsb_first(hash_val+i*SKEIN_256_BLOCK_BYTES, ctx->x,
-                                     n);
+               skein_put64_lsb_first(hash_val + i * SKEIN_256_BLOCK_BYTES,
+                                     ctx->x, n);
                /* restore the counter mode key for next time */
                memcpy(ctx->x, x, sizeof(x));
        }
@@ -812,19 +812,19 @@ int skein_512_output(struct skein_512_ctx *ctx, u8 *hash_val)
        memset(ctx->b, 0, sizeof(ctx->b));
        /* keep a local copy of counter mode "key" */
        memcpy(x, ctx->x, sizeof(x));
-       for (i = 0; i*SKEIN_512_BLOCK_BYTES < byte_cnt; i++) {
+       for (i = 0; i * SKEIN_512_BLOCK_BYTES < byte_cnt; i++) {
                /* build the counter block */
                ((u64 *)ctx->b)[0] = skein_swap64((u64) i);
                skein_start_new_type(ctx, OUT_FINAL);
                /* run "counter mode" */
                skein_512_process_block(ctx, ctx->b, 1, sizeof(u64));
                /* number of output bytes left to go */
-               n = byte_cnt - i*SKEIN_512_BLOCK_BYTES;
+               n = byte_cnt - i * SKEIN_512_BLOCK_BYTES;
                if (n >= SKEIN_512_BLOCK_BYTES)
                        n  = SKEIN_512_BLOCK_BYTES;
                /* "output" the ctr mode bytes */
-               skein_put64_lsb_first(hash_val+i*SKEIN_512_BLOCK_BYTES, ctx->x,
-                                     n);
+               skein_put64_lsb_first(hash_val + i * SKEIN_512_BLOCK_BYTES,
+                                     ctx->x, n);
                /* restore the counter mode key for next time */
                memcpy(ctx->x, x, sizeof(x));
        }
@@ -849,19 +849,19 @@ int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val)
        memset(ctx->b, 0, sizeof(ctx->b));
        /* keep a local copy of counter mode "key" */
        memcpy(x, ctx->x, sizeof(x));
-       for (i = 0; i*SKEIN_1024_BLOCK_BYTES < byte_cnt; i++) {
+       for (i = 0; i * SKEIN_1024_BLOCK_BYTES < byte_cnt; i++) {
                /* build the counter block */
                ((u64 *)ctx->b)[0] = skein_swap64((u64) i);
                skein_start_new_type(ctx, OUT_FINAL);
                /* run "counter mode" */
                skein_1024_process_block(ctx, ctx->b, 1, sizeof(u64));
                /* number of output bytes left to go */
-               n = byte_cnt - i*SKEIN_1024_BLOCK_BYTES;
+               n = byte_cnt - i * SKEIN_1024_BLOCK_BYTES;
                if (n >= SKEIN_1024_BLOCK_BYTES)
                        n  = SKEIN_1024_BLOCK_BYTES;
                /* "output" the ctr mode bytes */
-               skein_put64_lsb_first(hash_val+i*SKEIN_1024_BLOCK_BYTES, ctx->x,
-                                     n);
+               skein_put64_lsb_first(hash_val + i * SKEIN_1024_BLOCK_BYTES,
+                               ctx->x, n);
                /* restore the counter mode key for next time */
                memcpy(ctx->x, x, sizeof(x));
        }

diff --git a/drivers/staging/skein/skein_base.h b/drivers/staging/skein/skein_base.h
index 9c4be1ab2c5d5e1210437d854c295e5867c317c4..6289e1ee3afa77a7795e883d0908413c9cf0b1ba 100644 (file)
--- a/drivers/staging/skein/skein_base.h
+++ b/drivers/staging/skein/skein_base.h
@@ -32,7 +32,7 @@
 /* below two prototype assume we are handed aligned data */
 #define skein_put64_lsb_first(dst08, src64, b_cnt) memcpy(dst08, src64, b_cnt)
 #define skein_get64_lsb_first(dst64, src08, w_cnt) \
-               memcpy(dst64, src08, 8*(w_cnt))
+               memcpy(dst64, src08, 8 * (w_cnt))
 #define skein_swap64(w64)  (w64)
 
 enum {
@@ -48,17 +48,17 @@ enum {
 #define  SKEIN_1024_STATE_WORDS 16
 #define  SKEIN_MAX_STATE_WORDS 16
 
-#define  SKEIN_256_STATE_BYTES  (8*SKEIN_256_STATE_WORDS)
-#define  SKEIN_512_STATE_BYTES  (8*SKEIN_512_STATE_WORDS)
-#define  SKEIN_1024_STATE_BYTES  (8*SKEIN_1024_STATE_WORDS)
+#define  SKEIN_256_STATE_BYTES  (8 * SKEIN_256_STATE_WORDS)
+#define  SKEIN_512_STATE_BYTES  (8 * SKEIN_512_STATE_WORDS)
+#define  SKEIN_1024_STATE_BYTES (8 * SKEIN_1024_STATE_WORDS)
 
-#define  SKEIN_256_STATE_BITS  (64*SKEIN_256_STATE_WORDS)
-#define  SKEIN_512_STATE_BITS  (64*SKEIN_512_STATE_WORDS)
-#define  SKEIN_1024_STATE_BITS  (64*SKEIN_1024_STATE_WORDS)
+#define  SKEIN_256_STATE_BITS   (64 * SKEIN_256_STATE_WORDS)
+#define  SKEIN_512_STATE_BITS   (64 * SKEIN_512_STATE_WORDS)
+#define  SKEIN_1024_STATE_BITS  (64 * SKEIN_1024_STATE_WORDS)
 
-#define  SKEIN_256_BLOCK_BYTES  (8*SKEIN_256_STATE_WORDS)
-#define  SKEIN_512_BLOCK_BYTES  (8*SKEIN_512_STATE_WORDS)
-#define  SKEIN_1024_BLOCK_BYTES  (8*SKEIN_1024_STATE_WORDS)
+#define  SKEIN_256_BLOCK_BYTES  (8 * SKEIN_256_STATE_WORDS)
+#define  SKEIN_512_BLOCK_BYTES  (8 * SKEIN_512_STATE_WORDS)
+#define  SKEIN_1024_BLOCK_BYTES (8 * SKEIN_1024_STATE_WORDS)
 
 struct skein_ctx_hdr {
        size_t hash_bit_len;            /* size of hash result, in bits */
@@ -203,7 +203,7 @@ int skein_1024_output(struct skein_1024_ctx *ctx, u8 *hash_val);
 #define SKEIN_SCHEMA_VER        SKEIN_MK_64(SKEIN_VERSION, SKEIN_ID_STRING_LE)
 #define SKEIN_KS_PARITY         SKEIN_MK_64(0x1BD11BDA, 0xA9FC1A22)
 
-#define SKEIN_CFG_STR_LEN       (4*8)
+#define SKEIN_CFG_STR_LEN       (4 * 8)
 
 /* bit field definitions in config block tree_info word */
 #define SKEIN_CFG_TREE_LEAF_SIZE_POS  (0)
@@ -322,9 +322,9 @@ enum {
 #define SKEIN_512_ROUNDS_TOTAL (72)
 #define SKEIN_1024_ROUNDS_TOTAL (80)
 #else                  /* allow command-line define in range 8*(5..14)   */
-#define SKEIN_256_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS/100) + 5) % 10) + 5))
-#define SKEIN_512_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS/10)  + 5) % 10) + 5))
-#define SKEIN_1024_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS)     + 5) % 10) + 5))
+#define SKEIN_256_ROUNDS_TOTAL  (8 * ((((SKEIN_ROUNDS / 100) + 5) % 10) + 5))
+#define SKEIN_512_ROUNDS_TOTAL  (8 * ((((SKEIN_ROUNDS / 10)  + 5) % 10) + 5))
+#define SKEIN_1024_ROUNDS_TOTAL (8 * ((((SKEIN_ROUNDS)       + 5) % 10) + 5))
 #endif
 
 #endif  /* ifndef _SKEIN_H_ */

diff --git a/drivers/staging/skein/skein_block.c b/drivers/staging/skein/skein_block.c
index 1a547b307b33a2719972ce87ac141b55b767eda5..a1a3c398135d2880389394c2e138444f31f995ab 100644 (file)
--- a/drivers/staging/skein/skein_block.c
+++ b/drivers/staging/skein/skein_block.c
@@ -121,10 +121,10 @@
 
 #if !(SKEIN_USE_ASM & 512)
 #undef  RCNT
-#define RCNT  (SKEIN_512_ROUNDS_TOTAL/8)
+#define RCNT  (SKEIN_512_ROUNDS_TOTAL / 8)
 
 #ifdef SKEIN_LOOP /* configure how much to unroll the loop */
-#define SKEIN_UNROLL_512 (((SKEIN_LOOP)/10)%10)
+#define SKEIN_UNROLL_512 (((SKEIN_LOOP) / 10) % 10)
 #else
 #define SKEIN_UNROLL_512 (0)
 #endif
@@ -202,7 +202,7 @@
        } while (0)
 #define R512_UNROLL_R(NN)                             \
                ((SKEIN_UNROLL_512 == 0 &&            \
-               SKEIN_512_ROUNDS_TOTAL/8 > (NN)) ||   \
+               SKEIN_512_ROUNDS_TOTAL / 8 > (NN)) || \
                (SKEIN_UNROLL_512 > (NN)))
 
 #if  (SKEIN_UNROLL_512 > 14)
@@ -212,7 +212,7 @@
 
 #if !(SKEIN_USE_ASM & 1024)
 #undef  RCNT
-#define RCNT  (SKEIN_1024_ROUNDS_TOTAL/8)
+#define RCNT  (SKEIN_1024_ROUNDS_TOTAL / 8)
 #ifdef SKEIN_LOOP /* configure how much to unroll the loop */
 #define SKEIN_UNROLL_1024 ((SKEIN_LOOP) % 10)
 #else
@@ -313,28 +313,28 @@
 #define R1024_8_ROUNDS(R)                                                 \
        do {                                                              \
                R1024(00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, \
-                     13, 14, 15, R1024_0, 8*(R) + 1);                    \
+                     13, 14, 15, R1024_0, 8 * (R) + 1);                  \
                R1024(00, 09, 02, 13, 06, 11, 04, 15, 10, 07, 12, 03, 14, \
-                     05, 08, 01, R1024_1, 8*(R) + 2);                    \
+                     05, 08, 01, R1024_1, 8 * (R) + 2);                  \
                R1024(00, 07, 02, 05, 04, 03, 06, 01, 12, 15, 14, 13, 08, \
-                     11, 10, 09, R1024_2, 8*(R) + 3);                    \
+                     11, 10, 09, R1024_2, 8 * (R) + 3);                  \
                R1024(00, 15, 02, 11, 06, 13, 04, 09, 14, 01, 08, 05, 10, \
-                     03, 12, 07, R1024_3, 8*(R) + 4);                    \
-               I1024(2*(R));                                             \
+                     03, 12, 07, R1024_3, 8 * (R) + 4);                  \
+               I1024(2 * (R));                                           \
                R1024(00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, \
-                     13, 14, 15, R1024_4, 8*(R) + 5);                    \
+                     13, 14, 15, R1024_4, 8 * (R) + 5);                  \
                R1024(00, 09, 02, 13, 06, 11, 04, 15, 10, 07, 12, 03, 14, \
-                     05, 08, 01, R1024_5, 8*(R) + 6);                    \
+                     05, 08, 01, R1024_5, 8 * (R) + 6);                  \
                R1024(00, 07, 02, 05, 04, 03, 06, 01, 12, 15, 14, 13, 08, \
-                     11, 10, 09, R1024_6, 8*(R) + 7);                    \
+                     11, 10, 09, R1024_6, 8  * (R) + 7);                 \
                R1024(00, 15, 02, 11, 06, 13, 04, 09, 14, 01, 08, 05, 10, \
-                     03, 12, 07, R1024_7, 8*(R) + 8);                    \
-               I1024(2*(R)+1);                                           \
+                     03, 12, 07, R1024_7, 8 * (R) + 8);                  \
+               I1024(2 * (R) + 1);                                        \
        } while (0)
 
 #define R1024_UNROLL_R(NN)                              \
                ((SKEIN_UNROLL_1024 == 0 &&             \
-               SKEIN_1024_ROUNDS_TOTAL/8 > (NN)) ||    \
+               SKEIN_1024_ROUNDS_TOTAL / 8 > (NN)) ||  \
                (SKEIN_UNROLL_1024 > (NN)))
 
 #if  (SKEIN_UNROLL_1024 > 14)
@@ -353,10 +353,10 @@ void skein_256_process_block(struct skein_256_ctx *ctx, const u8 *blk_ptr,
        size_t r;
 #if SKEIN_UNROLL_256
        /* key schedule: chaining vars + tweak + "rot"*/
-       u64  kw[WCNT+4+RCNT*2];
+       u64  kw[WCNT + 4 + RCNT * 2];
 #else
        /* key schedule words : chaining vars + tweak */
-       u64  kw[WCNT+4];
+       u64  kw[WCNT + 4];
 #endif
        u64  X0, X1, X2, X3; /* local copy of context vars, for speed */
        u64  w[WCNT]; /* local copy of input block */
@@ -482,9 +482,11 @@ void skein_512_process_block(struct skein_512_ctx *ctx, const u8 *blk_ptr,
        };
        size_t  r;
 #if SKEIN_UNROLL_512
-       u64  kw[WCNT+4+RCNT*2]; /* key sched: chaining vars + tweak + "rot"*/
+       /* key sched: chaining vars + tweak + "rot"*/
+       u64  kw[WCNT + 4 + RCNT * 2];
 #else
-       u64  kw[WCNT+4]; /* key schedule words : chaining vars + tweak */
+       /* key schedule words : chaining vars + tweak */
+       u64  kw[WCNT + 4];
 #endif
        u64  X0, X1, X2, X3, X4, X5, X6, X7; /* local copies, for speed */
        u64  w[WCNT]; /* local copy of input block */
@@ -631,9 +633,11 @@ void skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
        };
        size_t  r;
 #if (SKEIN_UNROLL_1024 != 0)
-       u64  kw[WCNT+4+RCNT*2]; /* key sched: chaining vars + tweak + "rot" */
+       /* key sched: chaining vars + tweak + "rot" */
+       u64  kw[WCNT + 4 + RCNT * 2];
 #else
-       u64  kw[WCNT+4]; /* key schedule words : chaining vars + tweak */
+       /* key schedule words : chaining vars + tweak */
+       u64  kw[WCNT + 4];
 #endif
 
        /* local copy of vars, for speed */

diff --git a/drivers/staging/skein/threefish_api.h b/drivers/staging/skein/threefish_api.h
index 8e0a0b77eccebc2ee20585045148116c6b866c3e..615e467579eeacd72196883d0cbfe5ab2eb3c9a1 100644 (file)
--- a/drivers/staging/skein/threefish_api.h
+++ b/drivers/staging/skein/threefish_api.h
@@ -52,7 +52,7 @@ enum threefish_size {
  */
 struct threefish_key {
        u64 state_size;
-       u64 key[SKEIN_MAX_STATE_WORDS+1];   /* max number of key words*/
+       u64 key[SKEIN_MAX_STATE_WORDS + 1];   /* max number of key words*/
        u64 tweak[3];
 };