* Re: [PATCH] staging: skein: Adds test vectors & cleans up maros
[not found] ` <K4II4Hd----0@tutanota.de>
@ 2015-11-29 18:12 ` Gregkh
[not found] ` <K4RcNO5----0@tutanota.de-K4RcNOr--3-0>
0 siblings, 1 reply; 5+ messages in thread
From: Gregkh @ 2015-11-29 18:12 UTC (permalink / raw)
To: jpage; +Cc: linux-kernel, Jason
On Sun, Nov 29, 2015 at 12:51:30PM +0000, jpage@tutanota.de wrote:
> The patch for cleaning up the Skein hash implementation is included below.
>
> The test & pass vectors for the hash function have been included, but not
> checked as the competition is still ongoing,as the final specification is
> unknown at this time.
>
> The files are verbatim lifted from the author's website (https://
> www.schneier.com/code/skein_NIST_CD_102610.zip).
> The changes provide by me are moving all macros in the .c files to their
> repective .h files. As this was strictly a cosmetic change, I have not tested
> it with a rebuild.
>
> This patch helps move the Skein driver along towards completion.
>
> A signed version of this patch is included in the attachments.
> Also, please sign my attached GPG Key, if possible.
> Thank you.
> Signed-off-by: Sanidhya Solanki <jpage@tutanota.de>
>
Lots of this should be below in the changelog itself, the patch should
be "self-contained" and not need to be hand-edited in order to be
applied.
>
> commit 6d50eca21b913f47899d9b91413968b8bccb6e31
> Author: Sanidhya Solanki <jpage@tutanota.de>
> Date: Fri Nov 27 01:54:23 2015 -0500
Why is this all here? Please use git send-email to send a patch if your
email client can't just send them directly.
>
> - Added Test files.
> - Moved macros to appropriate Header Files.
> - Cleaned up TODO & added contact information.
> - Passing Test Vectors remains.
> - Adding module support remains.
That's a lot of different things all at once, please break this up into
a patch series, each one doing only one thing.
>
> Changes to be committed:
> modified: drivers/staging/skein/TODO
> modified: drivers/staging/skein/skein_block.c
> copied: drivers/staging/skein/skein_block.c -> drivers/staging/
> skein/skein_block.h
> new file: drivers/staging/skein/skein_test.c
> new file: drivers/staging/skein/skein_test.h
What is all of these lines for?
And you don't have a signed-off-by in the patch body itself. My scripts
warned you about all of the above last time, why didn't you pay
attention to them?
And finally, please use scripts/get_maintainer.pl to determine the
correct people and mailing lists to send a patch to.
hope this helps,
greg k-h
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] staging: skein: cleans up macros
[not found] ` <K4RhFyt----0@tutanota.de>
@ 2015-12-01 15:14 ` Gregkh
2015-12-03 15:47 ` Jason Cooper
[not found] ` <K4fop6l----0@tutanota.de>
2 siblings, 0 replies; 5+ messages in thread
From: Gregkh @ 2015-12-01 15:14 UTC (permalink / raw)
To: Sanidhya Solanki
Cc: mathieu.poirier, Jason, deepa.kernel, brcnakalin, vatikaharlalka,
devel, Linux Kernel
On Tue, Dec 01, 2015 at 08:42:28AM +0000, Sanidhya Solanki wrote:
> Patch moves the headers found in the "skein_block.c" to "skein_block.h".
Why?
> Compiled & checked: no errors found.
Why is this line here?
> Signed-off-by: Sanidhya Solanki <jpage@tutanota.de>
You sent this as a html patch, which can't be applied, please fix up
your email client to not sent html emails to kernel mailing lists.
thanks,
greg k-h
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] staging: skein: cleans up macros
[not found] ` <K4RhFyt----0@tutanota.de>
2015-12-01 15:14 ` [PATCH] staging: skein: cleans up macros Gregkh
@ 2015-12-03 15:47 ` Jason Cooper
[not found] ` <K4fop6l----0@tutanota.de>
2 siblings, 0 replies; 5+ messages in thread
From: Jason Cooper @ 2015-12-03 15:47 UTC (permalink / raw)
To: Sanidhya Solanki
Cc: Gregkh, mathieu.poirier, deepa.kernel, brcnakalin,
vatikaharlalka, devel, Linux Kernel
Sanidhya,
Sorry I haven't been very responsive, but I'm glad to see your progress
here.
Once you make the recommended changes, try using 'git format-patch' and
'git send-email' to pick and send the patch to the mailinglists.
On Tue, Dec 01, 2015 at 08:42:28AM +0000, Sanidhya Solanki wrote:
> Patch moves the headers found in the "skein_block.c" to "skein_block.h".
Please reword:
The original code defined macros in the source code, making it harder to
read. Move them to the header file.
> Compiled & checked: no errors found.
If you want to let us know this, you can put these kinds of comments
below the '---' ...
> Signed-off-by: Sanidhya Solanki <jpage@tutanota.de>
> ---
Which is here. That will prevent them from becoming a part of the
commit log.
> drivers/staging/skein/skein_block.c | 321
> -----------------------------------
> drivers/staging/skein/skein_block.h | 323
> ++++++++++++++++++++++++++++++++++++
> 2 files changed, 323 insertions(+), 321 deletions(-)
using the git tools mentioned above will prevent these kinds of wrapping
problems, which also affect the content of the patch.
Also, if this completes the TODO item, please include the change
removing the item from TODO.
Since this is your first submission, I'll toss this out there: Don't go
redo the work to make the recommended changes. git is designed to help
with this.
Say you were developing on the git branch 'my_changes',
$ git checkout -b my_changes_v2 my_changes
$ $EDITOR drivers/staging/skein/TODO
$ git add drivers/staging/skein/TODO
$ git commit -m "fixup: add TODO changes"
$ git rebase -i HEAD^^
change 'pick' to 'fixup' for the last commit
save and exit
$ git show
confirm one commit has everything
$ git format-patch ...
$ $EDITOR 0001-*.patch
$ git send-email ...
If it gets all fouled up, don't panic. you can checkout 'my_changes'
and it's in it's original state. :-)
hth,
Jason.
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] staging: skein: macros moved to header file
[not found] ` <K4fop6l----0@tutanota.de>
@ 2015-12-04 12:35 ` Jason Cooper
2015-12-04 14:25 ` Mathieu Poirier
1 sibling, 0 replies; 5+ messages in thread
From: Jason Cooper @ 2015-12-04 12:35 UTC (permalink / raw)
To: Sanidhya Solanki
Cc: Gregkh, mathieu.poirier, deepa.kernel, brcnakalin,
vatikaharlalka, devel, Linux Kernel
Oh hell. :)
Go ahead and try to configure git send-mail, or configure Thunderbird
according to Documentation/email-clients.txt. If you want, send it to
me off list first to confirm it's not getting mangled like below.
I think you just won the obfuscated C contest...
thx,
Jason.
On Fri, Dec 04, 2015 at 07:09:49AM +0000, Sanidhya Solanki wrote:
> Staging: Skein: Moved macros from skein_block.c to header file.
> The original code defined macros in the source code, making it harder toread.
> Move them to the header file.
> Signed-off-by: Sanidhya Solanki
> <jpage@tutanota.de>--- drivers/staging/skein/skein_block.c | 321
> ----------------------------------- drivers/staging/skein/skein_block.h | 323
> ++++++++++++++++++++++++++++++++++++ 2 files changed, 323 insertions(+), 321
> deletions(-)
> diff --git a/drivers/staging/skein/skein_block.c
> b/drivers/staging/skein/skein_block.cindex 45b4732..9701f95 100644---
> a/drivers/staging/skein/skein_block.c+++
> b/drivers/staging/skein/skein_block.c@@ -18,327 +18,6 @@ #include
> "skein_base.h" #include "skein_block.h" -#ifndef SKEIN_USE_ASM-#define
> SKEIN_USE_ASM (0) /* default is all C code (no ASM) */-#endif--#ifndef
> SKEIN_LOOP-#define SKEIN_LOOP 001 /* default: unroll 256 and 512, but not
> 1024 */-#endif--#define BLK_BITS (WCNT * 64) /* some useful
> definitions for code here */-#define KW_TWK_BASE (0)-#define KW_KEY_BASE
> (3)-#define ks (kw + KW_KEY_BASE)-#define ts
> (kw + KW_TWK_BASE)--#ifdef SKEIN_DEBUG-#define debug_save_tweak(ctx)
> \-{ \- ctx->h.tweak[0] = ts[0];
> \- ctx->h.tweak[1] = ts[1]; \-}-#else-#define
> debug_save_tweak(ctx)-#endif--#if !(SKEIN_USE_ASM & 256)-#undef RCNT-#define
> RCNT (SKEIN_256_ROUNDS_TOTAL / 8)-#ifdef SKEIN_LOOP /* configure how much to
> unroll the loop */-#define SKEIN_UNROLL_256 (((SKEIN_LOOP) / 100) %
> 10)-#else-#define SKEIN_UNROLL_256 (0)-#endif--#if SKEIN_UNROLL_256-#if (RCNT
> % SKEIN_UNROLL_256)-#error "Invalid SKEIN_UNROLL_256" /* sanity check on
> unroll count */-#endif-#endif-#define ROUND256(p0, p1, p2, p3, ROT, r_num)
> \- do { \- X##p0 += X##p1;
> \- X##p1 = rotl_64(X##p1, ROT##_0); \- X##p1 ^= X##p0;
> \- X##p2 += X##p3; \- X##p3 =
> rotl_64(X##p3, ROT##_1); \- X##p3 ^= X##p2; \- }
> while (0)--#if SKEIN_UNROLL_256 == 0-#define R256(p0, p1, p2, p3, ROT, r_num)
> /* fully unrolled */ \- ROUND256(p0, p1, p2, p3, ROT, r_num)--#define I256(R)
> \- do {
> \- /* inject the key schedule
> value */ \- X0 += ks[((R) + 1) % 5];
> \- X1 += ks[((R) + 2) % 5] + ts[((R) + 1) % 3]; \- X2
> += ks[((R) + 3) % 5] + ts[((R) + 2) % 3]; \- X3 += ks[((R) + 4)
> % 5] + (R) + 1; \- } while (0)-#else-/* looping version
> */-#define R256(p0, p1, p2, p3, ROT, r_num) ROUND256(p0, p1, p2, p3, ROT,
> r_num)--#define I256(R) \- do {
> \- /* inject the key schedule value */
> \- X0 += ks[r + (R) + 0]; \- X1 += ks[r + (R) + 1] +
> ts[r + (R) + 0];\- X2 += ks[r + (R) + 2] + ts[r + (R) + 1];\- X3 += ks[r +
> (R) + 3] + r + (R); \- /* rotate key schedule */
> \- ks[r + (R) + 4] = ks[r + (R) - 1]; \- ts[r + (R) + 2] = ts[r + (R)
> - 1]; \- } while (0)-#endif-#define R256_8_ROUNDS(R)
> \- do { \- R256(0, 1,
> 2, 3, R_256_0, 8 * (R) + 1); \- R256(0, 3, 2, 1, R_256_1, 8 * (R) + 2);
> \- R256(0, 1, 2, 3, R_256_2, 8 * (R) + 3); \- R256(0, 3, 2, 1, R_256_3, 8 *
> (R) + 4); \- I256(2 * (R)); \- R256(0, 1, 2, 3,
> R_256_4, 8 * (R) + 5); \- R256(0, 3, 2, 1, R_256_5, 8 * (R) + 6);
> \- R256(0, 1, 2, 3, R_256_6, 8 * (R) + 7); \- R256(0, 3, 2, 1, R_256_7, 8 *
> (R) + 8); \- I256(2 * (R) + 1); \- } while (0)--#define
> R256_UNROLL_R(NN) \- ((SKEIN_UNROLL_256 == 0 &&
> \- SKEIN_256_ROUNDS_TOTAL / 8 > (NN)) || \- (SKEIN_UNROLL_256 > (NN)))--#if
> (SKEIN_UNROLL_256 > 14)-#error "need more unrolling in
> skein_256_process_block"-#endif-#endif--#if !(SKEIN_USE_ASM & 512)-#undef
> RCNT-#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)-#else-#define SKEIN_UNROLL_512 (0)-#endif--#if
> SKEIN_UNROLL_512-#if (RCNT % SKEIN_UNROLL_512)-#error "Invalid
> SKEIN_UNROLL_512" /* sanity check on unroll count */-#endif-#endif-#define
> ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \- do {
> \- X##p0 += X##p1;
> \- X##p1 = rotl_64(X##p1, ROT##_0); \- X##p1 ^=
> X##p0; \- X##p2 += X##p3;
> \- X##p3 = rotl_64(X##p3, ROT##_1); \- X##p3
> ^= X##p2; \- X##p4 += X##p5;
> \- X##p5 = rotl_64(X##p5, ROT##_2); \- X##p5
> ^= X##p4; \- X##p6 += X##p7; X##p7 =
> rotl_64(X##p7, ROT##_3);\- X##p7 ^= X##p6;
> \- } while (0)--#if SKEIN_UNROLL_512 == 0-#define R512(p0, p1, p2, p3, p4,
> p5, p6, p7, ROT, r_num) /* unrolled */ \- ROUND512(p0, p1, p2, p3, p4, p5,
> p6, p7, ROT, r_num)--#define I512(R)
> \- do {
> \- /* inject the key schedule value */ \- X0 +=
> ks[((R) + 1) % 9]; \- X1 += ks[((R) + 2) %
> 9]; \- X2 += ks[((R) + 3) % 9];
> \- X3 += ks[((R) + 4) % 9];
> \- X4 += ks[((R) + 5) % 9]; \- X5 +=
> ks[((R) + 6) % 9] + ts[((R) + 1) % 3]; \- X6 += ks[((R) + 7) % 9]
> + ts[((R) + 2) % 3]; \- X7 += ks[((R) + 8) % 9] + (R) + 1;
> \- } while (0)--#else /* looping version */-#define R512(p0, p1,
> p2, p3, p4, p5, p6, p7, ROT, r_num) \- ROUND512(p0, p1, p2,
> p3, p4, p5, p6, p7, ROT, r_num) \--#define I512(R)
> \- do {
> \- /* inject the key schedule value */
> \- X0 += ks[r + (R) + 0];
> \- X1 += ks[r + (R) + 1]; \- X2 += ks[r
> + (R) + 2]; \- X3 += ks[r + (R) + 3];
> \- X4 += ks[r + (R) + 4];
> \- X5 += ks[r + (R) + 5] + ts[r + (R) + 0]; \- X6
> += ks[r + (R) + 6] + ts[r + (R) + 1]; \- X7 += ks[r + (R) +
> 7] + r + (R); \- /* rotate key schedule */
> \- ks[r + (R) + 8] = ks[r + (R) - 1];
> \- ts[r + (R) + 2] = ts[r + (R) - 1]; \- } while
> (0)-#endif /* end of looped code definitions */-#define R512_8_ROUNDS(R) /*
> do 8 full rounds */ \- do {
> \- R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_0, 8
> * (R) + 1); \- R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_1, 8 * (R) + 2);
> \- R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_2, 8 * (R) + 3); \- R512(6, 1, 0,
> 7, 2, 5, 4, 3, R_512_3, 8 * (R) + 4); \- I512(2 * (R));
> \- R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_4, 8 * (R) +
> 5); \- R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_5, 8 * (R) + 6);
> \- R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_6, 8 * (R) + 7); \- R512(6, 1, 0,
> 7, 2, 5, 4, 3, R_512_7, 8 * (R) + 8); \- I512(2 * (R) + 1); /* and key
> injection */ \- } while (0)-#define R512_UNROLL_R(NN)
> \- ((SKEIN_UNROLL_512 == 0 &&
> \- SKEIN_512_ROUNDS_TOTAL/8 > (NN)) || \- (SKEIN_UNROLL_512 >
> (NN)))--#if (SKEIN_UNROLL_512 > 14)-#error "need more unrolling in
> skein_512_process_block"-#endif-#endif--#if !(SKEIN_USE_ASM & 1024)-#undef
> RCNT-#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-#define SKEIN_UNROLL_1024 (0)-#endif--#if
> (SKEIN_UNROLL_1024 != 0)-#if (RCNT % SKEIN_UNROLL_1024)-#error "Invalid
> SKEIN_UNROLL_1024" /* sanity check on unroll count */-#endif-#endif-#define
> ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \-
> pF, ROT, r_num) \- do {
> \- X##p0 += X##p1;
> \- X##p1 = rotl_64(X##p1,
> ROT##_0); \- X##p1 ^= X##p0;
> \- X##p2 += X##p3;
> \- X##p3 = rotl_64(X##p3, ROT##_1);
> \- X##p3 ^= X##p2;
> \- X##p4 += X##p5; \- X##p5 =
> rotl_64(X##p5, ROT##_2); \- X##p5 ^= X##p4;
> \- X##p6 += X##p7;
> \- X##p7 = rotl_64(X##p7, ROT##_3);
> \- X##p7 ^= X##p6;
> \- X##p8 += X##p9;
> \- X##p9 = rotl_64(X##p9, ROT##_4); \- X##p9
> ^= X##p8; \- X##pA += X##pB;
> \- X##pB = rotl_64(X##pB,
> ROT##_5); \- X##pB ^= X##pA;
> \- X##pC += X##pD;
> \- X##pD = rotl_64(X##pD, ROT##_6);
> \- X##pD ^= X##pC;
> \- X##pE += X##pF; \- X##pF =
> rotl_64(X##pF, ROT##_7); \- X##pF ^= X##pE;
> \- } while (0)--#if
> SKEIN_UNROLL_1024 == 0-#define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9,
> pA, pB, pC, pD, pE, pF, \- ROT, rn)
> \- ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA,
> pB, pC, pD, pE, \- pF, ROT, rn)
> \--#define I1024(R) \- do
> { \- /* inject the key
> schedule value */ \- X00 += ks[((R) + 1) % 17];
> \- X01 += ks[((R) + 2) % 17]; \- X02 += ks[((R) +
> 3) % 17]; \- X03 += ks[((R) + 4) % 17];
> \- X04 += ks[((R) + 5) % 17]; \- X05 += ks[((R) +
> 6) % 17]; \- X06 += ks[((R) + 7) % 17];
> \- X07 += ks[((R) + 8) % 17]; \- X08 += ks[((R) +
> 9) % 17]; \- X09 += ks[((R) + 10) % 17];
> \- X10 += ks[((R) + 11) % 17]; \- X11 += ks[((R)
> + 12) % 17]; \- X12 += ks[((R) + 13) % 17];
> \- X13 += ks[((R) + 14) % 17] + ts[((R) + 1) % 3]; \- X14 +=
> ks[((R) + 15) % 17] + ts[((R) + 2) % 3]; \- X15 += ks[((R) + 16) % 17] + (R)
> + 1; \- } while (0)-#else /* looping version */-#define R1024(p0,
> p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, pF, \- ROT, rn)
> \- ROUND1024(p0, p1,
> p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \- pF, ROT, rn)
> \--#define I1024(R)
> \- do {
> \- /* inject the key schedule value */
> \- X00 += ks[r + (R) + 0];
> \- X01 += ks[r + (R) + 1]; \- X02 += ks[r +
> (R) + 2]; \- X03 += ks[r + (R) + 3];
> \- X04 += ks[r + (R) + 4];
> \- X05 += ks[r + (R) + 5]; \- X06 +=
> ks[r + (R) + 6]; \- X07 += ks[r + (R) + 7];
> \- X08 += ks[r + (R) + 8];
> \- X09 += ks[r + (R) + 9];
> \- X10 += ks[r + (R) + 10]; \- X11 += ks[r +
> (R) + 11]; \- X12 += ks[r + (R) + 12];
> \- X13 += ks[r + (R) + 13] + ts[r + (R) + 0];
> \- X14 += ks[r + (R) + 14] + ts[r + (R) + 1]; \- X15 +=
> ks[r + (R) + 15] + r + (R); \- /* rotate key schedule
> */ \- ks[r + (R) + 16] = ks[r + (R) - 1];
> \- ts[r + (R) + 2] = ts[r + (R) - 1];
> \- } while (0)--#endif-#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); \- R1024(00, 09,
> 02, 13, 06, 11, 04, 15, 10, 07, 12, 03, 14, \- 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);
> \- 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));
> \- R1024(00, 01, 02, 03, 04, 05, 06, 07, 08,
> 09, 10, 11, 12, \- 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); \- R1024(00, 07, 02, 05, 04,
> 03, 06, 01, 12, 15, 14, 13, 08, \- 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); \- } while
> (0)--#define R1024_UNROLL_R(NN)
> \- ((SKEIN_UNROLL_1024 == 0 && \- SKEIN_1024_ROUNDS_TOTAL/8 >
> (NN)) || \- (SKEIN_UNROLL_1024 > (NN)))--#if (SKEIN_UNROLL_1024 >
> 14)-#error "need more unrolling in
> Skein_1024_Process_Block"-#endif-#endif /*****************************
> SKEIN_256 ******************************/ #if !(SKEIN_USE_ASM & 256)diff
> --git a/drivers/staging/skein/skein_block.h
> b/drivers/staging/skein/skein_block.hindex 9d40f4a..1b28d52 100644---
> a/drivers/staging/skein/skein_block.h+++
> b/drivers/staging/skein/skein_block.h@@ -20,3 +20,326 @@ void
> skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
> size_t blk_cnt, size_t byte_cnt_add); #endif+++#ifndef
> SKEIN_USE_ASM+#define SKEIN_USE_ASM (0) /* default is all C code (no ASM)
> */+#endif++#ifndef SKEIN_LOOP+#define SKEIN_LOOP 001 /* default: unroll 256
> and 512, but not 1024 */+#endif++#define BLK_BITS (WCNT * 64) /* some
> useful definitions for code here */+#define KW_TWK_BASE (0)+#define
> KW_KEY_BASE (3)+#define ks (kw + KW_KEY_BASE)+#define ts
> (kw + KW_TWK_BASE)++#ifdef SKEIN_DEBUG+#define debug_save_tweak(ctx)
> \+{ \+ ctx->h.tweak[0] = ts[0];
> \+ ctx->h.tweak[1] = ts[1]; \+}+#else+#define
> debug_save_tweak(ctx)+#endif++#if !(SKEIN_USE_ASM & 256)+#undef RCNT+#define
> RCNT (SKEIN_256_ROUNDS_TOTAL / 8)+#ifdef SKEIN_LOOP /* configure how much to
> unroll the loop */+#define SKEIN_UNROLL_256 (((SKEIN_LOOP) / 100) %
> 10)+#else+#define SKEIN_UNROLL_256 (0)+#endif++#if SKEIN_UNROLL_256+#if (RCNT
> % SKEIN_UNROLL_256)+#error "Invalid SKEIN_UNROLL_256" /* sanity check on
> unroll count */+#endif+#endif+#define ROUND256(p0, p1, p2, p3, ROT, r_num)
> \+ do { \+ X##p0 += X##p1;
> \+ X##p1 = rotl_64(X##p1, ROT##_0); \+ X##p1 ^= X##p0;
> \+ X##p2 += X##p3; \+ X##p3 =
> rotl_64(X##p3, ROT##_1); \+ X##p3 ^= X##p2; \+ }
> while (0)++#if SKEIN_UNROLL_256 == 0+#define R256(p0, p1, p2, p3, ROT, r_num)
> /* fully unrolled */ \+ ROUND256(p0, p1, p2, p3, ROT, r_num)++#define I256(R)
> \+ do {
> \+ /* inject the key schedule
> value */ \+ X0 += ks[((R) + 1) % 5];
> \+ X1 += ks[((R) + 2) % 5] + ts[((R) + 1) % 3]; \+ X2
> += ks[((R) + 3) % 5] + ts[((R) + 2) % 3]; \+ X3 += ks[((R) + 4)
> % 5] + (R) + 1; \+ } while (0)+#else+/* looping version
> */+#define R256(p0, p1, p2, p3, ROT, r_num) ROUND256(p0, p1, p2, p3, ROT,
> r_num)++#define I256(R) \+ do {
> \+ /* inject the key schedule value */
> \+ X0 += ks[r + (R) + 0]; \+ X1 += ks[r + (R) + 1] +
> ts[r + (R) + 0];\+ X2 += ks[r + (R) + 2] + ts[r + (R) + 1];\+ X3 += ks[r +
> (R) + 3] + r + (R); \+ /* rotate key schedule */
> \+ ks[r + (R) + 4] = ks[r + (R) - 1]; \+ ts[r + (R) + 2] = ts[r + (R)
> - 1]; \+ } while (0)+#endif+#define R256_8_ROUNDS(R)
> \+ do { \+ R256(0, 1,
> 2, 3, R_256_0, 8 * (R) + 1); \+ R256(0, 3, 2, 1, R_256_1, 8 * (R) + 2);
> \+ R256(0, 1, 2, 3, R_256_2, 8 * (R) + 3); \+ R256(0, 3, 2, 1, R_256_3, 8 *
> (R) + 4); \+ I256(2 * (R)); \+ R256(0, 1, 2, 3,
> R_256_4, 8 * (R) + 5); \+ R256(0, 3, 2, 1, R_256_5, 8 * (R) + 6);
> \+ R256(0, 1, 2, 3, R_256_6, 8 * (R) + 7); \+ R256(0, 3, 2, 1, R_256_7, 8 *
> (R) + 8); \+ I256(2 * (R) + 1); \+ } while (0)++#define
> R256_UNROLL_R(NN) \+ ((SKEIN_UNROLL_256 == 0 &&
> \+ SKEIN_256_ROUNDS_TOTAL / 8 > (NN)) || \+ (SKEIN_UNROLL_256 > (NN)))++#if
> (SKEIN_UNROLL_256 > 14)+#error "need more unrolling in
> skein_256_process_block"+#endif+#endif++#if !(SKEIN_USE_ASM & 512)+#undef
> RCNT+#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)+#else+#define SKEIN_UNROLL_512 (0)+#endif++#if
> SKEIN_UNROLL_512+#if (RCNT % SKEIN_UNROLL_512)+#error "Invalid
> SKEIN_UNROLL_512" /* sanity check on unroll count */+#endif+#endif+#define
> ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \+ do {
> \+ X##p0 += X##p1;
> \+ X##p1 = rotl_64(X##p1, ROT##_0); \+ X##p1 ^=
> X##p0; \+ X##p2 += X##p3;
> \+ X##p3 = rotl_64(X##p3, ROT##_1); \+ X##p3
> ^= X##p2; \+ X##p4 += X##p5;
> \+ X##p5 = rotl_64(X##p5, ROT##_2); \+ X##p5
> ^= X##p4; \+ X##p6 += X##p7; X##p7 =
> rotl_64(X##p7, ROT##_3);\+ X##p7 ^= X##p6;
> \+ } while (0)++#if SKEIN_UNROLL_512 == 0+#define R512(p0, p1, p2, p3, p4,
> p5, p6, p7, ROT, r_num) /* unrolled */ \+ ROUND512(p0, p1, p2, p3, p4, p5,
> p6, p7, ROT, r_num)++#define I512(R)
> \+ do {
> \+ /* inject the key schedule value */ \+ X0 +=
> ks[((R) + 1) % 9]; \+ X1 += ks[((R) + 2) %
> 9]; \+ X2 += ks[((R) + 3) % 9];
> \+ X3 += ks[((R) + 4) % 9];
> \+ X4 += ks[((R) + 5) % 9]; \+ X5 +=
> ks[((R) + 6) % 9] + ts[((R) + 1) % 3]; \+ X6 += ks[((R) + 7) % 9]
> + ts[((R) + 2) % 3]; \+ X7 += ks[((R) + 8) % 9] + (R) + 1;
> \+ } while (0)++#else /* looping version */+#define R512(p0, p1,
> p2, p3, p4, p5, p6, p7, ROT, r_num) \+ ROUND512(p0, p1, p2,
> p3, p4, p5, p6, p7, ROT, r_num) \++#define I512(R)
> \+ do {
> \+ /* inject the key schedule value */
> \+ X0 += ks[r + (R) + 0];
> \+ X1 += ks[r + (R) + 1]; \+ X2 += ks[r
> + (R) + 2]; \+ X3 += ks[r + (R) + 3];
> \+ X4 += ks[r + (R) + 4];
> \+ X5 += ks[r + (R) + 5] + ts[r + (R) + 0]; \+ X6
> += ks[r + (R) + 6] + ts[r + (R) + 1]; \+ X7 += ks[r + (R) +
> 7] + r + (R); \+ /* rotate key schedule */
> \+ ks[r + (R) + 8] = ks[r + (R) - 1];
> \+ ts[r + (R) + 2] = ts[r + (R) - 1]; \+ } while
> (0)+#endif /* end of looped code definitions */+#define R512_8_ROUNDS(R) /*
> do 8 full rounds */ \+ do {
> \+ R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_0, 8
> * (R) + 1); \+ R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_1, 8 * (R) + 2);
> \+ R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_2, 8 * (R) + 3); \+ R512(6, 1, 0,
> 7, 2, 5, 4, 3, R_512_3, 8 * (R) + 4); \+ I512(2 * (R));
> \+ R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_4, 8 * (R) +
> 5); \+ R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_5, 8 * (R) + 6);
> \+ R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_6, 8 * (R) + 7); \+ R512(6, 1, 0,
> 7, 2, 5, 4, 3, R_512_7, 8 * (R) + 8); \+ I512(2 * (R) + 1); /* and key
> injection */ \+ } while (0)+#define R512_UNROLL_R(NN)
> \+ ((SKEIN_UNROLL_512 == 0 &&
> \+ SKEIN_512_ROUNDS_TOTAL/8 > (NN)) || \+ (SKEIN_UNROLL_512 >
> (NN)))++#if (SKEIN_UNROLL_512 > 14)+#error "need more unrolling in
> skein_512_process_block"+#endif+#endif++#if !(SKEIN_USE_ASM & 1024)+#undef
> RCNT+#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+#define SKEIN_UNROLL_1024 (0)+#endif++#if
> (SKEIN_UNROLL_1024 != 0)+#if (RCNT % SKEIN_UNROLL_1024)+#error "Invalid
> SKEIN_UNROLL_1024" /* sanity check on unroll count */+#endif+#endif+#define
> ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \+
> pF, ROT, r_num) \+ do {
> \+ X##p0 += X##p1;
> \+ X##p1 = rotl_64(X##p1,
> ROT##_0); \+ X##p1 ^= X##p0;
> \+ X##p2 += X##p3;
> \+ X##p3 = rotl_64(X##p3, ROT##_1);
> \+ X##p3 ^= X##p2;
> \+ X##p4 += X##p5; \+ X##p5 =
> rotl_64(X##p5, ROT##_2); \+ X##p5 ^= X##p4;
> \+ X##p6 += X##p7;
> \+ X##p7 = rotl_64(X##p7, ROT##_3);
> \+ X##p7 ^= X##p6;
> \+ X##p8 += X##p9;
> \+ X##p9 = rotl_64(X##p9, ROT##_4); \+ X##p9
> ^= X##p8; \+ X##pA += X##pB;
> \+ X##pB = rotl_64(X##pB,
> ROT##_5); \+ X##pB ^= X##pA;
> \+ X##pC += X##pD;
> \+ X##pD = rotl_64(X##pD, ROT##_6);
> \+ X##pD ^= X##pC;
> \+ X##pE += X##pF; \+ X##pF =
> rotl_64(X##pF, ROT##_7); \+ X##pF ^= X##pE;
> \+ } while (0)++#if
> SKEIN_UNROLL_1024 == 0+#define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9,
> pA, pB, pC, pD, pE, pF, \+ ROT, rn)
> \+ ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA,
> pB, pC, pD, pE, \+ pF, ROT, rn)
> \++#define I1024(R) \+ do
> { \+ /* inject the key
> schedule value */ \+ X00 += ks[((R) + 1) % 17];
> \+ X01 += ks[((R) + 2) % 17]; \+ X02 += ks[((R) +
> 3) % 17]; \+ X03 += ks[((R) + 4) % 17];
> \+ X04 += ks[((R) + 5) % 17]; \+ X05 += ks[((R) +
> 6) % 17]; \+ X06 += ks[((R) + 7) % 17];
> \+ X07 += ks[((R) + 8) % 17]; \+ X08 += ks[((R) +
> 9) % 17]; \+ X09 += ks[((R) + 10) % 17];
> \+ X10 += ks[((R) + 11) % 17]; \+ X11 += ks[((R)
> + 12) % 17]; \+ X12 += ks[((R) + 13) % 17];
> \+ X13 += ks[((R) + 14) % 17] + ts[((R) + 1) % 3]; \+ X14 +=
> ks[((R) + 15) % 17] + ts[((R) + 2) % 3]; \+ X15 += ks[((R) + 16) % 17] + (R)
> + 1; \+ } while (0)+#else /* looping version */+#define R1024(p0,
> p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, pF, \+ ROT, rn)
> \+ ROUND1024(p0, p1,
> p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \+ pF, ROT, rn)
> \++#define I1024(R)
> \+ do {
> \+ /* inject the key schedule value */
> \+ X00 += ks[r + (R) + 0];
> \+ X01 += ks[r + (R) + 1]; \+ X02 += ks[r +
> (R) + 2]; \+ X03 += ks[r + (R) + 3];
> \+ X04 += ks[r + (R) + 4];
> \+ X05 += ks[r + (R) + 5]; \+ X06 +=
> ks[r + (R) + 6]; \+ X07 += ks[r + (R) + 7];
> \+ X08 += ks[r + (R) + 8];
> \+ X09 += ks[r + (R) + 9];
> \+ X10 += ks[r + (R) + 10]; \+ X11 += ks[r +
> (R) + 11]; \+ X12 += ks[r + (R) + 12];
> \+ X13 += ks[r + (R) + 13] + ts[r + (R) + 0];
> \+ X14 += ks[r + (R) + 14] + ts[r + (R) + 1]; \+ X15 +=
> ks[r + (R) + 15] + r + (R); \+ /* rotate key schedule
> */ \+ ks[r + (R) + 16] = ks[r + (R) - 1];
> \+ ts[r + (R) + 2] = ts[r + (R) - 1];
> \+ } while (0)++#endif+#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); \+ R1024(00, 09,
> 02, 13, 06, 11, 04, 15, 10, 07, 12, 03, 14, \+ 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);
> \+ 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));
> \+ R1024(00, 01, 02, 03, 04, 05, 06, 07, 08,
> 09, 10, 11, 12, \+ 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); \+ R1024(00, 07, 02, 05, 04,
> 03, 06, 01, 12, 15, 14, 13, 08, \+ 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); \+ } while
> (0)++#define R1024_UNROLL_R(NN)
> \+ ((SKEIN_UNROLL_1024 == 0 && \+ SKEIN_1024_ROUNDS_TOTAL/8 >
> (NN)) || \+ (SKEIN_UNROLL_1024 > (NN)))++#if (SKEIN_UNROLL_1024 >
> 14)+#error "need more unrolling in
> Skein_1024_Process_Block"+#endif+#endif-- 2.5.0
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] staging: skein: macros moved to header file
[not found] ` <K4fop6l----0@tutanota.de>
2015-12-04 12:35 ` [PATCH] staging: skein: macros moved to header file Jason Cooper
@ 2015-12-04 14:25 ` Mathieu Poirier
1 sibling, 0 replies; 5+ messages in thread
From: Mathieu Poirier @ 2015-12-04 14:25 UTC (permalink / raw)
To: Sanidhya Solanki
Cc: Gregkh, Jason, deepa.kernel, brcnakalin, vatikaharlalka, devel,
Linux Kernel
On 4 December 2015 at 00:09, Sanidhya Solanki <jpage@tutanota.de> wrote:
> Staging: Skein: Moved macros from skein_block.c to header file.
>
> The original code defined macros in the source code, making it harder to
> read. Move them to the header file.
The patch didn't end up mangled on my side but definitely did not
cleared checkpatch, which may indicate some sort of problem with the
email client (as I assume you did indeed run checkpatch.sh).
It would also be a good idea to update the TODO file to reflect that
some of the macros have now been moved to a header file.
I will review the work when checkpatch is happy.
Thanks,
Mathieu
>
> Signed-off-by: Sanidhya Solanki <jpage@tutanota.de>
> ---
> drivers/staging/skein/skein_block.c | 321
> -----------------------------------
> drivers/staging/skein/skein_block.h | 323
> ++++++++++++++++++++++++++++++++++++
> 2 files changed, 323 insertions(+), 321 deletions(-)
>
> diff --git a/drivers/staging/skein/skein_block.c
> b/drivers/staging/skein/skein_block.c
> index 45b4732..9701f95 100644
> --- a/drivers/staging/skein/skein_block.c
> +++ b/drivers/staging/skein/skein_block.c
> @@ -18,327 +18,6 @@
> #include "skein_base.h"
> #include "skein_block.h"
>
> -#ifndef SKEIN_USE_ASM
> -#define SKEIN_USE_ASM (0) /* default is all C code (no ASM) */
> -#endif
> -
> -#ifndef SKEIN_LOOP
> -#define SKEIN_LOOP 001 /* default: unroll 256 and 512, but not 1024 */
> -#endif
> -
> -#define BLK_BITS (WCNT * 64) /* some useful definitions for code
> here */
> -#define KW_TWK_BASE (0)
> -#define KW_KEY_BASE (3)
> -#define ks (kw + KW_KEY_BASE)
> -#define ts (kw + KW_TWK_BASE)
> -
> -#ifdef SKEIN_DEBUG
> -#define debug_save_tweak(ctx) \
> -{ \
> - ctx->h.tweak[0] = ts[0]; \
> - ctx->h.tweak[1] = ts[1]; \
> -}
> -#else
> -#define debug_save_tweak(ctx)
> -#endif
> -
> -#if !(SKEIN_USE_ASM & 256)
> -#undef RCNT
> -#define RCNT (SKEIN_256_ROUNDS_TOTAL / 8)
> -#ifdef SKEIN_LOOP /* configure how much to unroll the loop */
> -#define SKEIN_UNROLL_256 (((SKEIN_LOOP) / 100) % 10)
> -#else
> -#define SKEIN_UNROLL_256 (0)
> -#endif
> -
> -#if SKEIN_UNROLL_256
> -#if (RCNT % SKEIN_UNROLL_256)
> -#error "Invalid SKEIN_UNROLL_256" /* sanity check on unroll count */
> -#endif
> -#endif
> -#define ROUND256(p0, p1, p2, p3, ROT, r_num) \
> - do { \
> - X##p0 += X##p1; \
> - X##p1 = rotl_64(X##p1, ROT##_0); \
> - X##p1 ^= X##p0; \
> - X##p2 += X##p3; \
> - X##p3 = rotl_64(X##p3, ROT##_1); \
> - X##p3 ^= X##p2; \
> - } while (0)
> -
> -#if SKEIN_UNROLL_256 == 0
> -#define R256(p0, p1, p2, p3, ROT, r_num) /* fully unrolled */ \
> - ROUND256(p0, p1, p2, p3, ROT, r_num)
> -
> -#define I256(R) \
> - do { \
> - /* inject the key schedule value */ \
> - X0 += ks[((R) + 1) % 5]; \
> - X1 += ks[((R) + 2) % 5] + ts[((R) + 1) % 3]; \
> - X2 += ks[((R) + 3) % 5] + ts[((R) + 2) % 3]; \
> - X3 += ks[((R) + 4) % 5] + (R) + 1; \
> - } while (0)
> -#else
> -/* looping version */
> -#define R256(p0, p1, p2, p3, ROT, r_num) ROUND256(p0, p1, p2, p3, ROT,
> r_num)
> -
> -#define I256(R) \
> - do { \
> - /* inject the key schedule value */ \
> - X0 += ks[r + (R) + 0]; \
> - X1 += ks[r + (R) + 1] + ts[r + (R) + 0];\
> - X2 += ks[r + (R) + 2] + ts[r + (R) + 1];\
> - X3 += ks[r + (R) + 3] + r + (R); \
> - /* rotate key schedule */ \
> - ks[r + (R) + 4] = ks[r + (R) - 1]; \
> - ts[r + (R) + 2] = ts[r + (R) - 1]; \
> - } while (0)
> -#endif
> -#define R256_8_ROUNDS(R) \
> - do { \
> - R256(0, 1, 2, 3, R_256_0, 8 * (R) + 1); \
> - R256(0, 3, 2, 1, R_256_1, 8 * (R) + 2); \
> - R256(0, 1, 2, 3, R_256_2, 8 * (R) + 3); \
> - R256(0, 3, 2, 1, R_256_3, 8 * (R) + 4); \
> - I256(2 * (R)); \
> - R256(0, 1, 2, 3, R_256_4, 8 * (R) + 5); \
> - R256(0, 3, 2, 1, R_256_5, 8 * (R) + 6); \
> - R256(0, 1, 2, 3, R_256_6, 8 * (R) + 7); \
> - R256(0, 3, 2, 1, R_256_7, 8 * (R) + 8); \
> - I256(2 * (R) + 1); \
> - } while (0)
> -
> -#define R256_UNROLL_R(NN) \
> - ((SKEIN_UNROLL_256 == 0 && \
> - SKEIN_256_ROUNDS_TOTAL / 8 > (NN)) || \
> - (SKEIN_UNROLL_256 > (NN)))
> -
> -#if (SKEIN_UNROLL_256 > 14)
> -#error "need more unrolling in skein_256_process_block"
> -#endif
> -#endif
> -
> -#if !(SKEIN_USE_ASM & 512)
> -#undef RCNT
> -#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)
> -#else
> -#define SKEIN_UNROLL_512 (0)
> -#endif
> -
> -#if SKEIN_UNROLL_512
> -#if (RCNT % SKEIN_UNROLL_512)
> -#error "Invalid SKEIN_UNROLL_512" /* sanity check on unroll count */
> -#endif
> -#endif
> -#define ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
> - do { \
> - X##p0 += X##p1; \
> - X##p1 = rotl_64(X##p1, ROT##_0); \
> - X##p1 ^= X##p0; \
> - X##p2 += X##p3; \
> - X##p3 = rotl_64(X##p3, ROT##_1); \
> - X##p3 ^= X##p2; \
> - X##p4 += X##p5; \
> - X##p5 = rotl_64(X##p5, ROT##_2); \
> - X##p5 ^= X##p4; \
> - X##p6 += X##p7; X##p7 = rotl_64(X##p7, ROT##_3);\
> - X##p7 ^= X##p6; \
> - } while (0)
> -
> -#if SKEIN_UNROLL_512 == 0
> -#define R512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) /* unrolled */ \
> - ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num)
> -
> -#define I512(R) \
> - do { \
> - /* inject the key schedule value */ \
> - X0 += ks[((R) + 1) % 9]; \
> - X1 += ks[((R) + 2) % 9]; \
> - X2 += ks[((R) + 3) % 9]; \
> - X3 += ks[((R) + 4) % 9]; \
> - X4 += ks[((R) + 5) % 9]; \
> - X5 += ks[((R) + 6) % 9] + ts[((R) + 1) % 3]; \
> - X6 += ks[((R) + 7) % 9] + ts[((R) + 2) % 3]; \
> - X7 += ks[((R) + 8) % 9] + (R) + 1; \
> - } while (0)
> -
> -#else /* looping version */
> -#define R512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
> - ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
> -
> -#define I512(R) \
> - do { \
> - /* inject the key schedule value */ \
> - X0 += ks[r + (R) + 0]; \
> - X1 += ks[r + (R) + 1]; \
> - X2 += ks[r + (R) + 2]; \
> - X3 += ks[r + (R) + 3]; \
> - X4 += ks[r + (R) + 4]; \
> - X5 += ks[r + (R) + 5] + ts[r + (R) + 0]; \
> - X6 += ks[r + (R) + 6] + ts[r + (R) + 1]; \
> - X7 += ks[r + (R) + 7] + r + (R); \
> - /* rotate key schedule */ \
> - ks[r + (R) + 8] = ks[r + (R) - 1]; \
> - ts[r + (R) + 2] = ts[r + (R) - 1]; \
> - } while (0)
> -#endif /* end of looped code definitions */
> -#define R512_8_ROUNDS(R) /* do 8 full rounds */ \
> - do { \
> - R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_0, 8 * (R) + 1); \
> - R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_1, 8 * (R) + 2); \
> - R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_2, 8 * (R) + 3); \
> - R512(6, 1, 0, 7, 2, 5, 4, 3, R_512_3, 8 * (R) + 4); \
> - I512(2 * (R)); \
> - R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_4, 8 * (R) + 5); \
> - R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_5, 8 * (R) + 6); \
> - R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_6, 8 * (R) + 7); \
> - R512(6, 1, 0, 7, 2, 5, 4, 3, R_512_7, 8 * (R) + 8); \
> - I512(2 * (R) + 1); /* and key injection */ \
> - } while (0)
> -#define R512_UNROLL_R(NN) \
> - ((SKEIN_UNROLL_512 == 0 && \
> - SKEIN_512_ROUNDS_TOTAL/8 > (NN)) || \
> - (SKEIN_UNROLL_512 > (NN)))
> -
> -#if (SKEIN_UNROLL_512 > 14)
> -#error "need more unrolling in skein_512_process_block"
> -#endif
> -#endif
> -
> -#if !(SKEIN_USE_ASM & 1024)
> -#undef RCNT
> -#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
> -#define SKEIN_UNROLL_1024 (0)
> -#endif
> -
> -#if (SKEIN_UNROLL_1024 != 0)
> -#if (RCNT % SKEIN_UNROLL_1024)
> -#error "Invalid SKEIN_UNROLL_1024" /* sanity check on unroll count */
> -#endif
> -#endif
> -#define ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD,
> pE, \
> - pF, ROT, r_num) \
> - do { \
> - X##p0 += X##p1; \
> - X##p1 = rotl_64(X##p1, ROT##_0); \
> - X##p1 ^= X##p0; \
> - X##p2 += X##p3; \
> - X##p3 = rotl_64(X##p3, ROT##_1); \
> - X##p3 ^= X##p2; \
> - X##p4 += X##p5; \
> - X##p5 = rotl_64(X##p5, ROT##_2); \
> - X##p5 ^= X##p4; \
> - X##p6 += X##p7; \
> - X##p7 = rotl_64(X##p7, ROT##_3); \
> - X##p7 ^= X##p6; \
> - X##p8 += X##p9; \
> - X##p9 = rotl_64(X##p9, ROT##_4); \
> - X##p9 ^= X##p8; \
> - X##pA += X##pB; \
> - X##pB = rotl_64(X##pB, ROT##_5); \
> - X##pB ^= X##pA; \
> - X##pC += X##pD; \
> - X##pD = rotl_64(X##pD, ROT##_6); \
> - X##pD ^= X##pC; \
> - X##pE += X##pF; \
> - X##pF = rotl_64(X##pF, ROT##_7); \
> - X##pF ^= X##pE; \
> - } while (0)
> -
> -#if SKEIN_UNROLL_1024 == 0
> -#define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE,
> pF, \
> - ROT, rn) \
> - ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \
> - pF, ROT, rn) \
> -
> -#define I1024(R) \
> - do { \
> - /* inject the key schedule value */ \
> - X00 += ks[((R) + 1) % 17]; \
> - X01 += ks[((R) + 2) % 17]; \
> - X02 += ks[((R) + 3) % 17]; \
> - X03 += ks[((R) + 4) % 17]; \
> - X04 += ks[((R) + 5) % 17]; \
> - X05 += ks[((R) + 6) % 17]; \
> - X06 += ks[((R) + 7) % 17]; \
> - X07 += ks[((R) + 8) % 17]; \
> - X08 += ks[((R) + 9) % 17]; \
> - X09 += ks[((R) + 10) % 17]; \
> - X10 += ks[((R) + 11) % 17]; \
> - X11 += ks[((R) + 12) % 17]; \
> - X12 += ks[((R) + 13) % 17]; \
> - X13 += ks[((R) + 14) % 17] + ts[((R) + 1) % 3]; \
> - X14 += ks[((R) + 15) % 17] + ts[((R) + 2) % 3]; \
> - X15 += ks[((R) + 16) % 17] + (R) + 1; \
> - } while (0)
> -#else /* looping version */
> -#define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE,
> pF, \
> - ROT, rn) \
> - ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \
> - pF, ROT, rn) \
> -
> -#define I1024(R) \
> - do { \
> - /* inject the key schedule value */ \
> - X00 += ks[r + (R) + 0]; \
> - X01 += ks[r + (R) + 1]; \
> - X02 += ks[r + (R) + 2]; \
> - X03 += ks[r + (R) + 3]; \
> - X04 += ks[r + (R) + 4]; \
> - X05 += ks[r + (R) + 5]; \
> - X06 += ks[r + (R) + 6]; \
> - X07 += ks[r + (R) + 7]; \
> - X08 += ks[r + (R) + 8]; \
> - X09 += ks[r + (R) + 9]; \
> - X10 += ks[r + (R) + 10]; \
> - X11 += ks[r + (R) + 11]; \
> - X12 += ks[r + (R) + 12]; \
> - X13 += ks[r + (R) + 13] + ts[r + (R) + 0]; \
> - X14 += ks[r + (R) + 14] + ts[r + (R) + 1]; \
> - X15 += ks[r + (R) + 15] + r + (R); \
> - /* rotate key schedule */ \
> - ks[r + (R) + 16] = ks[r + (R) - 1]; \
> - ts[r + (R) + 2] = ts[r + (R) - 1]; \
> - } while (0)
> -
> -#endif
> -#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); \
> - R1024(00, 09, 02, 13, 06, 11, 04, 15, 10, 07, 12, 03, 14, \
> - 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); \
> - 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)); \
> - R1024(00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, \
> - 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); \
> - R1024(00, 07, 02, 05, 04, 03, 06, 01, 12, 15, 14, 13, 08, \
> - 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); \
> - } while (0)
> -
> -#define R1024_UNROLL_R(NN) \
> - ((SKEIN_UNROLL_1024 == 0 && \
> - SKEIN_1024_ROUNDS_TOTAL/8 > (NN)) || \
> - (SKEIN_UNROLL_1024 > (NN)))
> -
> -#if (SKEIN_UNROLL_1024 > 14)
> -#error "need more unrolling in Skein_1024_Process_Block"
> -#endif
> -#endif
>
> /***************************** SKEIN_256 ******************************/
> #if !(SKEIN_USE_ASM & 256)
> diff --git a/drivers/staging/skein/skein_block.h
> b/drivers/staging/skein/skein_block.h
> index 9d40f4a..1b28d52 100644
> --- a/drivers/staging/skein/skein_block.h
> +++ b/drivers/staging/skein/skein_block.h
> @@ -20,3 +20,326 @@ void skein_1024_process_block(struct skein_1024_ctx
> *ctx, const u8 *blk_ptr,
> size_t blk_cnt, size_t byte_cnt_add);
>
> #endif
> +
> +
> +#ifndef SKEIN_USE_ASM
> +#define SKEIN_USE_ASM (0) /* default is all C code (no ASM) */
> +#endif
> +
> +#ifndef SKEIN_LOOP
> +#define SKEIN_LOOP 001 /* default: unroll 256 and 512, but not 1024 */
> +#endif
> +
> +#define BLK_BITS (WCNT * 64) /* some useful definitions for code
> here */
> +#define KW_TWK_BASE (0)
> +#define KW_KEY_BASE (3)
> +#define ks (kw + KW_KEY_BASE)
> +#define ts (kw + KW_TWK_BASE)
> +
> +#ifdef SKEIN_DEBUG
> +#define debug_save_tweak(ctx) \
> +{ \
> + ctx->h.tweak[0] = ts[0]; \
> + ctx->h.tweak[1] = ts[1]; \
> +}
> +#else
> +#define debug_save_tweak(ctx)
> +#endif
> +
> +#if !(SKEIN_USE_ASM & 256)
> +#undef RCNT
> +#define RCNT (SKEIN_256_ROUNDS_TOTAL / 8)
> +#ifdef SKEIN_LOOP /* configure how much to unroll the loop */
> +#define SKEIN_UNROLL_256 (((SKEIN_LOOP) / 100) % 10)
> +#else
> +#define SKEIN_UNROLL_256 (0)
> +#endif
> +
> +#if SKEIN_UNROLL_256
> +#if (RCNT % SKEIN_UNROLL_256)
> +#error "Invalid SKEIN_UNROLL_256" /* sanity check on unroll count */
> +#endif
> +#endif
> +#define ROUND256(p0, p1, p2, p3, ROT, r_num) \
> + do { \
> + X##p0 += X##p1; \
> + X##p1 = rotl_64(X##p1, ROT##_0); \
> + X##p1 ^= X##p0; \
> + X##p2 += X##p3; \
> + X##p3 = rotl_64(X##p3, ROT##_1); \
> + X##p3 ^= X##p2; \
> + } while (0)
> +
> +#if SKEIN_UNROLL_256 == 0
> +#define R256(p0, p1, p2, p3, ROT, r_num) /* fully unrolled */ \
> + ROUND256(p0, p1, p2, p3, ROT, r_num)
> +
> +#define I256(R) \
> + do { \
> + /* inject the key schedule value */ \
> + X0 += ks[((R) + 1) % 5]; \
> + X1 += ks[((R) + 2) % 5] + ts[((R) + 1) % 3]; \
> + X2 += ks[((R) + 3) % 5] + ts[((R) + 2) % 3]; \
> + X3 += ks[((R) + 4) % 5] + (R) + 1; \
> + } while (0)
> +#else
> +/* looping version */
> +#define R256(p0, p1, p2, p3, ROT, r_num) ROUND256(p0, p1, p2, p3, ROT,
> r_num)
> +
> +#define I256(R) \
> + do { \
> + /* inject the key schedule value */ \
> + X0 += ks[r + (R) + 0]; \
> + X1 += ks[r + (R) + 1] + ts[r + (R) + 0];\
> + X2 += ks[r + (R) + 2] + ts[r + (R) + 1];\
> + X3 += ks[r + (R) + 3] + r + (R); \
> + /* rotate key schedule */ \
> + ks[r + (R) + 4] = ks[r + (R) - 1]; \
> + ts[r + (R) + 2] = ts[r + (R) - 1]; \
> + } while (0)
> +#endif
> +#define R256_8_ROUNDS(R) \
> + do { \
> + R256(0, 1, 2, 3, R_256_0, 8 * (R) + 1); \
> + R256(0, 3, 2, 1, R_256_1, 8 * (R) + 2); \
> + R256(0, 1, 2, 3, R_256_2, 8 * (R) + 3); \
> + R256(0, 3, 2, 1, R_256_3, 8 * (R) + 4); \
> + I256(2 * (R)); \
> + R256(0, 1, 2, 3, R_256_4, 8 * (R) + 5); \
> + R256(0, 3, 2, 1, R_256_5, 8 * (R) + 6); \
> + R256(0, 1, 2, 3, R_256_6, 8 * (R) + 7); \
> + R256(0, 3, 2, 1, R_256_7, 8 * (R) + 8); \
> + I256(2 * (R) + 1); \
> + } while (0)
> +
> +#define R256_UNROLL_R(NN) \
> + ((SKEIN_UNROLL_256 == 0 && \
> + SKEIN_256_ROUNDS_TOTAL / 8 > (NN)) || \
> + (SKEIN_UNROLL_256 > (NN)))
> +
> +#if (SKEIN_UNROLL_256 > 14)
> +#error "need more unrolling in skein_256_process_block"
> +#endif
> +#endif
> +
> +#if !(SKEIN_USE_ASM & 512)
> +#undef RCNT
> +#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)
> +#else
> +#define SKEIN_UNROLL_512 (0)
> +#endif
> +
> +#if SKEIN_UNROLL_512
> +#if (RCNT % SKEIN_UNROLL_512)
> +#error "Invalid SKEIN_UNROLL_512" /* sanity check on unroll count */
> +#endif
> +#endif
> +#define ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
> + do { \
> + X##p0 += X##p1; \
> + X##p1 = rotl_64(X##p1, ROT##_0); \
> + X##p1 ^= X##p0; \
> + X##p2 += X##p3; \
> + X##p3 = rotl_64(X##p3, ROT##_1); \
> + X##p3 ^= X##p2; \
> + X##p4 += X##p5; \
> + X##p5 = rotl_64(X##p5, ROT##_2); \
> + X##p5 ^= X##p4; \
> + X##p6 += X##p7; X##p7 = rotl_64(X##p7, ROT##_3);\
> + X##p7 ^= X##p6; \
> + } while (0)
> +
> +#if SKEIN_UNROLL_512 == 0
> +#define R512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) /* unrolled */ \
> + ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num)
> +
> +#define I512(R) \
> + do { \
> + /* inject the key schedule value */ \
> + X0 += ks[((R) + 1) % 9]; \
> + X1 += ks[((R) + 2) % 9]; \
> + X2 += ks[((R) + 3) % 9]; \
> + X3 += ks[((R) + 4) % 9]; \
> + X4 += ks[((R) + 5) % 9]; \
> + X5 += ks[((R) + 6) % 9] + ts[((R) + 1) % 3]; \
> + X6 += ks[((R) + 7) % 9] + ts[((R) + 2) % 3]; \
> + X7 += ks[((R) + 8) % 9] + (R) + 1; \
> + } while (0)
> +
> +#else /* looping version */
> +#define R512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
> + ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
> +
> +#define I512(R) \
> + do { \
> + /* inject the key schedule value */ \
> + X0 += ks[r + (R) + 0]; \
> + X1 += ks[r + (R) + 1]; \
> + X2 += ks[r + (R) + 2]; \
> + X3 += ks[r + (R) + 3]; \
> + X4 += ks[r + (R) + 4]; \
> + X5 += ks[r + (R) + 5] + ts[r + (R) + 0]; \
> + X6 += ks[r + (R) + 6] + ts[r + (R) + 1]; \
> + X7 += ks[r + (R) + 7] + r + (R); \
> + /* rotate key schedule */ \
> + ks[r + (R) + 8] = ks[r + (R) - 1]; \
> + ts[r + (R) + 2] = ts[r + (R) - 1]; \
> + } while (0)
> +#endif /* end of looped code definitions */
> +#define R512_8_ROUNDS(R) /* do 8 full rounds */ \
> + do { \
> + R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_0, 8 * (R) + 1); \
> + R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_1, 8 * (R) + 2); \
> + R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_2, 8 * (R) + 3); \
> + R512(6, 1, 0, 7, 2, 5, 4, 3, R_512_3, 8 * (R) + 4); \
> + I512(2 * (R)); \
> + R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_4, 8 * (R) + 5); \
> + R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_5, 8 * (R) + 6); \
> + R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_6, 8 * (R) + 7); \
> + R512(6, 1, 0, 7, 2, 5, 4, 3, R_512_7, 8 * (R) + 8); \
> + I512(2 * (R) + 1); /* and key injection */ \
> + } while (0)
> +#define R512_UNROLL_R(NN) \
> + ((SKEIN_UNROLL_512 == 0 && \
> + SKEIN_512_ROUNDS_TOTAL/8 > (NN)) || \
> + (SKEIN_UNROLL_512 > (NN)))
> +
> +#if (SKEIN_UNROLL_512 > 14)
> +#error "need more unrolling in skein_512_process_block"
> +#endif
> +#endif
> +
> +#if !(SKEIN_USE_ASM & 1024)
> +#undef RCNT
> +#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
> +#define SKEIN_UNROLL_1024 (0)
> +#endif
> +
> +#if (SKEIN_UNROLL_1024 != 0)
> +#if (RCNT % SKEIN_UNROLL_1024)
> +#error "Invalid SKEIN_UNROLL_1024" /* sanity check on unroll count */
> +#endif
> +#endif
> +#define ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD,
> pE, \
> + pF, ROT, r_num) \
> + do { \
> + X##p0 += X##p1; \
> + X##p1 = rotl_64(X##p1, ROT##_0); \
> + X##p1 ^= X##p0; \
> + X##p2 += X##p3; \
> + X##p3 = rotl_64(X##p3, ROT##_1); \
> + X##p3 ^= X##p2; \
> + X##p4 += X##p5; \
> + X##p5 = rotl_64(X##p5, ROT##_2); \
> + X##p5 ^= X##p4; \
> + X##p6 += X##p7; \
> + X##p7 = rotl_64(X##p7, ROT##_3); \
> + X##p7 ^= X##p6; \
> + X##p8 += X##p9; \
> + X##p9 = rotl_64(X##p9, ROT##_4); \
> + X##p9 ^= X##p8; \
> + X##pA += X##pB; \
> + X##pB = rotl_64(X##pB, ROT##_5); \
> + X##pB ^= X##pA; \
> + X##pC += X##pD; \
> + X##pD = rotl_64(X##pD, ROT##_6); \
> + X##pD ^= X##pC; \
> + X##pE += X##pF; \
> + X##pF = rotl_64(X##pF, ROT##_7); \
> + X##pF ^= X##pE; \
> + } while (0)
> +
> +#if SKEIN_UNROLL_1024 == 0
> +#define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE,
> pF, \
> + ROT, rn) \
> + ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \
> + pF, ROT, rn) \
> +
> +#define I1024(R) \
> + do { \
> + /* inject the key schedule value */ \
> + X00 += ks[((R) + 1) % 17]; \
> + X01 += ks[((R) + 2) % 17]; \
> + X02 += ks[((R) + 3) % 17]; \
> + X03 += ks[((R) + 4) % 17]; \
> + X04 += ks[((R) + 5) % 17]; \
> + X05 += ks[((R) + 6) % 17]; \
> + X06 += ks[((R) + 7) % 17]; \
> + X07 += ks[((R) + 8) % 17]; \
> + X08 += ks[((R) + 9) % 17]; \
> + X09 += ks[((R) + 10) % 17]; \
> + X10 += ks[((R) + 11) % 17]; \
> + X11 += ks[((R) + 12) % 17]; \
> + X12 += ks[((R) + 13) % 17]; \
> + X13 += ks[((R) + 14) % 17] + ts[((R) + 1) % 3]; \
> + X14 += ks[((R) + 15) % 17] + ts[((R) + 2) % 3]; \
> + X15 += ks[((R) + 16) % 17] + (R) + 1; \
> + } while (0)
> +#else /* looping version */
> +#define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE,
> pF, \
> + ROT, rn) \
> + ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \
> + pF, ROT, rn) \
> +
> +#define I1024(R) \
> + do { \
> + /* inject the key schedule value */ \
> + X00 += ks[r + (R) + 0]; \
> + X01 += ks[r + (R) + 1]; \
> + X02 += ks[r + (R) + 2]; \
> + X03 += ks[r + (R) + 3]; \
> + X04 += ks[r + (R) + 4]; \
> + X05 += ks[r + (R) + 5]; \
> + X06 += ks[r + (R) + 6]; \
> + X07 += ks[r + (R) + 7]; \
> + X08 += ks[r + (R) + 8]; \
> + X09 += ks[r + (R) + 9]; \
> + X10 += ks[r + (R) + 10]; \
> + X11 += ks[r + (R) + 11]; \
> + X12 += ks[r + (R) + 12]; \
> + X13 += ks[r + (R) + 13] + ts[r + (R) + 0]; \
> + X14 += ks[r + (R) + 14] + ts[r + (R) + 1]; \
> + X15 += ks[r + (R) + 15] + r + (R); \
> + /* rotate key schedule */ \
> + ks[r + (R) + 16] = ks[r + (R) - 1]; \
> + ts[r + (R) + 2] = ts[r + (R) - 1]; \
> + } while (0)
> +
> +#endif
> +#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); \
> + R1024(00, 09, 02, 13, 06, 11, 04, 15, 10, 07, 12, 03, 14, \
> + 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); \
> + 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)); \
> + R1024(00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, \
> + 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); \
> + R1024(00, 07, 02, 05, 04, 03, 06, 01, 12, 15, 14, 13, 08, \
> + 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); \
> + } while (0)
> +
> +#define R1024_UNROLL_R(NN) \
> + ((SKEIN_UNROLL_1024 == 0 && \
> + SKEIN_1024_ROUNDS_TOTAL/8 > (NN)) || \
> + (SKEIN_UNROLL_1024 > (NN)))
> +
> +#if (SKEIN_UNROLL_1024 > 14)
> +#error "need more unrolling in Skein_1024_Process_Block"
> +#endif
> +#endif
> --
> 2.5.0
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2015-12-04 14:25 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
[not found] <K4BZG5Z----0@tutanota.de>
[not found] ` <K4II4Hd----0@tutanota.de>
2015-11-29 18:12 ` [PATCH] staging: skein: Adds test vectors & cleans up maros Gregkh
[not found] ` <K4RcNO5----0@tutanota.de-K4RcNOr--3-0>
[not found] ` <K4RhFyt----0@tutanota.de>
2015-12-01 15:14 ` [PATCH] staging: skein: cleans up macros Gregkh
2015-12-03 15:47 ` Jason Cooper
[not found] ` <K4fop6l----0@tutanota.de>
2015-12-04 12:35 ` [PATCH] staging: skein: macros moved to header file Jason Cooper
2015-12-04 14:25 ` Mathieu Poirier
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
Powered by JetHome