LCOV - code coverage report
Current view: top level - raid - x86.c (source / functions) Hit Total Coverage
Test: lcov.info Lines: 684 684 100.0 %
Date: 2016-11-21 Functions: 14 14 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (C) 2013 Andrea Mazzoleni
       3             :  *
       4             :  * This program is free software: you can redistribute it and/or modify
       5             :  * it under the terms of the GNU General Public License as published by
       6             :  * the Free Software Foundation, either version 2 of the License, or
       7             :  * (at your option) any later version.
       8             :  *
       9             :  * This program is distributed in the hope that it will be useful,
      10             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      12             :  * GNU General Public License for more details.
      13             :  */
      14             : 
      15             : #include "internal.h"
      16             : #include "gf.h"
      17             : 
      18             : /*
      19             :  * For x86 optimizations you can see:
      20             :  *
      21             :  * Software optimization resources
      22             :  * http://www.agner.org/optimize/
      23             :  *
      24             :  * x86, x64 Instruction Latency, Memory Latency and CPUID dumps
      25             :  * http://users.atw.hu/instlatx64/
      26             :  */
      27             : 
      28             : #if defined(CONFIG_X86) && defined(CONFIG_SSE2)
      29             : /*
      30             :  * GEN1 (RAID5 with xor) SSE2 implementation
      31             :  *
      32             :  * Intentionally don't process more than 64 bytes because 64 is the typical
      33             :  * cache block, and processing 128 bytes doesn't increase performance, and in
      34             :  * some cases it even decreases it.
      35             :  */
      36      288948 : void raid_gen1_sse2(int nd, size_t size, void **vv)
      37             : {
      38      288948 :         uint8_t **v = (uint8_t **)vv;
      39             :         uint8_t *p;
      40             :         int d, l;
      41             :         size_t i;
      42             : 
      43      288948 :         l = nd - 1;
      44      288948 :         p = v[nd];
      45             : 
      46             :         raid_sse_begin();
      47             : 
      48     6140160 :         for (i = 0; i < size; i += 64) {
      49     5851212 :                 asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
      50     5851212 :                 asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
      51     5851212 :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (v[l][i + 32]));
      52     5851212 :                 asm volatile ("movdqa %0,%%xmm3" : : "m" (v[l][i + 48]));
      53    37573252 :                 for (d = l - 1; d >= 0; --d) {
      54    31722040 :                         asm volatile ("pxor %0,%%xmm0" : : "m" (v[d][i]));
      55    31722040 :                         asm volatile ("pxor %0,%%xmm1" : : "m" (v[d][i + 16]));
      56    31722040 :                         asm volatile ("pxor %0,%%xmm2" : : "m" (v[d][i + 32]));
      57    31722040 :                         asm volatile ("pxor %0,%%xmm3" : : "m" (v[d][i + 48]));
      58             :                 }
      59     5851212 :                 asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
      60     5851212 :                 asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
      61     5851212 :                 asm volatile ("movntdq %%xmm2,%0" : "=m" (p[i + 32]));
      62     5851212 :                 asm volatile ("movntdq %%xmm3,%0" : "=m" (p[i + 48]));
      63             :         }
      64             : 
      65             :         raid_sse_end();
      66      288948 : }
      67             : #endif
      68             : 
      69             : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
      70             : /*
      71             :  * GEN1 (RAID5 with xor) AVX2 implementation
      72             :  *
      73             :  * Intentionally don't process more than 64 bytes because 64 is the typical
      74             :  * cache block, and processing 128 bytes doesn't increase performance, and in
      75             :  * some cases it even decreases it.
      76             :  */
      77          97 : void raid_gen1_avx2(int nd, size_t size, void **vv)
      78             : {
      79          97 :         uint8_t **v = (uint8_t **)vv;
      80             :         uint8_t *p;
      81             :         int d, l;
      82             :         size_t i;
      83             : 
      84          97 :         l = nd - 1;
      85          97 :         p = v[nd];
      86             : 
      87             :         raid_avx_begin();
      88             : 
      89       50189 :         for (i = 0; i < size; i += 64) {
      90       50092 :                 asm volatile ("vmovdqa %0,%%ymm0" : : "m" (v[l][i]));
      91       50092 :                 asm volatile ("vmovdqa %0,%%ymm1" : : "m" (v[l][i + 32]));
      92      407172 :                 for (d = l - 1; d >= 0; --d) {
      93      357080 :                         asm volatile ("vpxor %0,%%ymm0,%%ymm0" : : "m" (v[d][i]));
      94      357080 :                         asm volatile ("vpxor %0,%%ymm1,%%ymm1" : : "m" (v[d][i + 32]));
      95             :                 }
      96       50092 :                 asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
      97       50092 :                 asm volatile ("vmovntdq %%ymm1,%0" : "=m" (p[i + 32]));
      98             :         }
      99             : 
     100             :         raid_avx_end();
     101          97 : }
     102             : #endif
     103             : 
     104             : #if defined(CONFIG_X86) && defined(CONFIG_SSE2)
     105             : static const struct gfconst16 {
     106             :         uint8_t poly[16];
     107             :         uint8_t low4[16];
     108             : } gfconst16 __aligned(32) = {
     109             :         {
     110             :                 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
     111             :                 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d
     112             :         },
     113             :         {
     114             :                 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
     115             :                 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f
     116             :         },
     117             : };
     118             : #endif
     119             : 
     120             : #if defined(CONFIG_X86) && defined(CONFIG_SSE2)
     121             : /*
     122             :  * GEN2 (RAID6 with powers of 2) SSE2 implementation
     123             :  */
     124      268716 : void raid_gen2_sse2(int nd, size_t size, void **vv)
     125             : {
     126      268716 :         uint8_t **v = (uint8_t **)vv;
     127             :         uint8_t *p;
     128             :         uint8_t *q;
     129             :         int d, l;
     130             :         size_t i;
     131             : 
     132      268716 :         l = nd - 1;
     133      268716 :         p = v[nd];
     134      268716 :         q = v[nd + 1];
     135             : 
     136             :         raid_sse_begin();
     137             : 
     138      268716 :         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
     139             : 
     140    10785156 :         for (i = 0; i < size; i += 32) {
     141    10516440 :                 asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
     142    10516440 :                 asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
     143    10516440 :                 asm volatile ("movdqa %xmm0,%xmm2");
     144    10516440 :                 asm volatile ("movdqa %xmm1,%xmm3");
     145    66949256 :                 for (d = l - 1; d >= 0; --d) {
     146    56432816 :                         asm volatile ("pxor %xmm4,%xmm4");
     147    56432816 :                         asm volatile ("pxor %xmm5,%xmm5");
     148    56432816 :                         asm volatile ("pcmpgtb %xmm2,%xmm4");
     149    56432816 :                         asm volatile ("pcmpgtb %xmm3,%xmm5");
     150    56432816 :                         asm volatile ("paddb %xmm2,%xmm2");
     151    56432816 :                         asm volatile ("paddb %xmm3,%xmm3");
     152    56432816 :                         asm volatile ("pand %xmm7,%xmm4");
     153    56432816 :                         asm volatile ("pand %xmm7,%xmm5");
     154    56432816 :                         asm volatile ("pxor %xmm4,%xmm2");
     155    56432816 :                         asm volatile ("pxor %xmm5,%xmm3");
     156             : 
     157    56432816 :                         asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
     158    56432816 :                         asm volatile ("movdqa %0,%%xmm5" : : "m" (v[d][i + 16]));
     159    56432816 :                         asm volatile ("pxor %xmm4,%xmm0");
     160    56432816 :                         asm volatile ("pxor %xmm5,%xmm1");
     161    56432816 :                         asm volatile ("pxor %xmm4,%xmm2");
     162    56432816 :                         asm volatile ("pxor %xmm5,%xmm3");
     163             :                 }
     164    10516440 :                 asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
     165    10516440 :                 asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
     166    10516440 :                 asm volatile ("movntdq %%xmm2,%0" : "=m" (q[i]));
     167    10516440 :                 asm volatile ("movntdq %%xmm3,%0" : "=m" (q[i + 16]));
     168             :         }
     169             : 
     170             :         raid_sse_end();
     171      268716 : }
     172             : #endif
     173             : 
     174             : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
     175             : /*
     176             :  * GEN2 (RAID6 with powers of 2) AVX2 implementation
     177             :  */
     178         510 : void raid_gen2_avx2(int nd, size_t size, void **vv)
     179             : {
     180         510 :         uint8_t **v = (uint8_t **)vv;
     181             :         uint8_t *p;
     182             :         uint8_t *q;
     183             :         int d, l;
     184             :         size_t i;
     185             : 
     186         510 :         l = nd - 1;
     187         510 :         p = v[nd];
     188         510 :         q = v[nd + 1];
     189             : 
     190             :         raid_avx_begin();
     191             : 
     192         510 :         asm volatile ("vbroadcasti128 %0, %%ymm7" : : "m" (gfconst16.poly[0]));
     193         510 :         asm volatile ("vpxor %ymm6,%ymm6,%ymm6");
     194             : 
     195      113754 :         for (i = 0; i < size; i += 64) {
     196      113244 :                 asm volatile ("vmovdqa %0,%%ymm0" : : "m" (v[l][i]));
     197      113244 :                 asm volatile ("vmovdqa %0,%%ymm1" : : "m" (v[l][i + 32]));
     198      113244 :                 asm volatile ("vmovdqa %ymm0,%ymm2");
     199      113244 :                 asm volatile ("vmovdqa %ymm1,%ymm3");
     200      919748 :                 for (d = l - 1; d >= 0; --d) {
     201      806504 :                         asm volatile ("vpcmpgtb %ymm2,%ymm6,%ymm4");
     202      806504 :                         asm volatile ("vpcmpgtb %ymm3,%ymm6,%ymm5");
     203      806504 :                         asm volatile ("vpaddb %ymm2,%ymm2,%ymm2");
     204      806504 :                         asm volatile ("vpaddb %ymm3,%ymm3,%ymm3");
     205      806504 :                         asm volatile ("vpand %ymm7,%ymm4,%ymm4");
     206      806504 :                         asm volatile ("vpand %ymm7,%ymm5,%ymm5");
     207      806504 :                         asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
     208      806504 :                         asm volatile ("vpxor %ymm5,%ymm3,%ymm3");
     209             : 
     210      806504 :                         asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
     211      806504 :                         asm volatile ("vmovdqa %0,%%ymm5" : : "m" (v[d][i + 32]));
     212      806504 :                         asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
     213      806504 :                         asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
     214      806504 :                         asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
     215      806504 :                         asm volatile ("vpxor %ymm5,%ymm3,%ymm3");
     216             :                 }
     217      113244 :                 asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
     218      113244 :                 asm volatile ("vmovntdq %%ymm1,%0" : "=m" (p[i + 32]));
     219      113244 :                 asm volatile ("vmovntdq %%ymm2,%0" : "=m" (q[i]));
     220      113244 :                 asm volatile ("vmovntdq %%ymm3,%0" : "=m" (q[i + 32]));
     221             :         }
     222             : 
     223             :         raid_avx_end();
     224         510 : }
     225             : #endif
     226             : 
     227             : #if defined(CONFIG_X86_64) && defined(CONFIG_SSE2)
     228             : /*
     229             :  * GEN2 (RAID6 with powers of 2) SSE2 implementation
     230             :  *
     231             :  * Note that it uses 16 registers, meaning that x64 is required.
     232             :  */
     233             : void raid_gen2_sse2ext(int nd, size_t size, void **vv)
     234             : {
     235             :         uint8_t **v = (uint8_t **)vv;
     236             :         uint8_t *p;
     237             :         uint8_t *q;
     238             :         int d, l;
     239             :         size_t i;
     240             : 
     241             :         l = nd - 1;
     242             :         p = v[nd];
     243             :         q = v[nd + 1];
     244             : 
     245             :         raid_sse_begin();
     246             : 
     247             :         asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.poly[0]));
     248             : 
     249             :         for (i = 0; i < size; i += 64) {
     250             :                 asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
     251             :                 asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
     252             :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (v[l][i + 32]));
     253             :                 asm volatile ("movdqa %0,%%xmm3" : : "m" (v[l][i + 48]));
     254             :                 asm volatile ("movdqa %xmm0,%xmm4");
     255             :                 asm volatile ("movdqa %xmm1,%xmm5");
     256             :                 asm volatile ("movdqa %xmm2,%xmm6");
     257             :                 asm volatile ("movdqa %xmm3,%xmm7");
     258             :                 for (d = l - 1; d >= 0; --d) {
     259             :                         asm volatile ("pxor %xmm8,%xmm8");
     260             :                         asm volatile ("pxor %xmm9,%xmm9");
     261             :                         asm volatile ("pxor %xmm10,%xmm10");
     262             :                         asm volatile ("pxor %xmm11,%xmm11");
     263             :                         asm volatile ("pcmpgtb %xmm4,%xmm8");
     264             :                         asm volatile ("pcmpgtb %xmm5,%xmm9");
     265             :                         asm volatile ("pcmpgtb %xmm6,%xmm10");
     266             :                         asm volatile ("pcmpgtb %xmm7,%xmm11");
     267             :                         asm volatile ("paddb %xmm4,%xmm4");
     268             :                         asm volatile ("paddb %xmm5,%xmm5");
     269             :                         asm volatile ("paddb %xmm6,%xmm6");
     270             :                         asm volatile ("paddb %xmm7,%xmm7");
     271             :                         asm volatile ("pand %xmm15,%xmm8");
     272             :                         asm volatile ("pand %xmm15,%xmm9");
     273             :                         asm volatile ("pand %xmm15,%xmm10");
     274             :                         asm volatile ("pand %xmm15,%xmm11");
     275             :                         asm volatile ("pxor %xmm8,%xmm4");
     276             :                         asm volatile ("pxor %xmm9,%xmm5");
     277             :                         asm volatile ("pxor %xmm10,%xmm6");
     278             :                         asm volatile ("pxor %xmm11,%xmm7");
     279             : 
     280             :                         asm volatile ("movdqa %0,%%xmm8" : : "m" (v[d][i]));
     281             :                         asm volatile ("movdqa %0,%%xmm9" : : "m" (v[d][i + 16]));
     282             :                         asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i + 32]));
     283             :                         asm volatile ("movdqa %0,%%xmm11" : : "m" (v[d][i + 48]));
     284             :                         asm volatile ("pxor %xmm8,%xmm0");
     285             :                         asm volatile ("pxor %xmm9,%xmm1");
     286             :                         asm volatile ("pxor %xmm10,%xmm2");
     287             :                         asm volatile ("pxor %xmm11,%xmm3");
     288             :                         asm volatile ("pxor %xmm8,%xmm4");
     289             :                         asm volatile ("pxor %xmm9,%xmm5");
     290             :                         asm volatile ("pxor %xmm10,%xmm6");
     291             :                         asm volatile ("pxor %xmm11,%xmm7");
     292             :                 }
     293             :                 asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
     294             :                 asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
     295             :                 asm volatile ("movntdq %%xmm2,%0" : "=m" (p[i + 32]));
     296             :                 asm volatile ("movntdq %%xmm3,%0" : "=m" (p[i + 48]));
     297             :                 asm volatile ("movntdq %%xmm4,%0" : "=m" (q[i]));
     298             :                 asm volatile ("movntdq %%xmm5,%0" : "=m" (q[i + 16]));
     299             :                 asm volatile ("movntdq %%xmm6,%0" : "=m" (q[i + 32]));
     300             :                 asm volatile ("movntdq %%xmm7,%0" : "=m" (q[i + 48]));
     301             :         }
     302             : 
     303             :         raid_sse_end();
     304             : }
     305             : #endif
     306             : 
     307             : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
     308             : /*
     309             :  * GEN3 (triple parity with Cauchy matrix) SSSE3 implementation
     310             :  */
     311       29542 : void raid_gen3_ssse3(int nd, size_t size, void **vv)
     312             : {
     313       29542 :         uint8_t **v = (uint8_t **)vv;
     314             :         uint8_t *p;
     315             :         uint8_t *q;
     316             :         uint8_t *r;
     317             :         int d, l;
     318             :         size_t i;
     319             : 
     320       29542 :         l = nd - 1;
     321       29542 :         p = v[nd];
     322       29542 :         q = v[nd + 1];
     323       29542 :         r = v[nd + 2];
     324             : 
     325             :         /* special case with only one data disk */
     326       29542 :         if (l == 0) {
     327           4 :                 for (i = 0; i < 3; ++i)
     328           3 :                         memcpy(v[1 + i], v[0], size);
     329       29543 :                 return;
     330             :         }
     331             : 
     332             :         raid_sse_begin();
     333             : 
     334             :         /* generic case with at least two data disks */
     335       29541 :         asm volatile ("movdqa %0,%%xmm3" : : "m" (gfconst16.poly[0]));
     336       29541 :         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
     337             : 
     338     4888821 :         for (i = 0; i < size; i += 16) {
     339             :                 /* last disk without the by two multiplication */
     340     4859280 :                 asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
     341             : 
     342     4859280 :                 asm volatile ("movdqa %xmm4,%xmm0");
     343     4859280 :                 asm volatile ("movdqa %xmm4,%xmm1");
     344             : 
     345     4859280 :                 asm volatile ("movdqa %xmm4,%xmm5");
     346     4859280 :                 asm volatile ("psrlw  $4,%xmm5");
     347     4859280 :                 asm volatile ("pand   %xmm7,%xmm4");
     348     4859280 :                 asm volatile ("pand   %xmm7,%xmm5");
     349             : 
     350     4859280 :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
     351     4859280 :                 asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[l][0][1][0]));
     352     4859280 :                 asm volatile ("pshufb %xmm4,%xmm2");
     353     4859280 :                 asm volatile ("pshufb %xmm5,%xmm6");
     354     4859280 :                 asm volatile ("pxor   %xmm6,%xmm2");
     355             : 
     356             :                 /* intermediate disks */
     357    30489328 :                 for (d = l - 1; d > 0; --d) {
     358    25630048 :                         asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
     359             : 
     360    25630048 :                         asm volatile ("pxor %xmm5,%xmm5");
     361    25630048 :                         asm volatile ("pcmpgtb %xmm1,%xmm5");
     362    25630048 :                         asm volatile ("paddb %xmm1,%xmm1");
     363    25630048 :                         asm volatile ("pand %xmm3,%xmm5");
     364    25630048 :                         asm volatile ("pxor %xmm5,%xmm1");
     365             : 
     366    25630048 :                         asm volatile ("pxor %xmm4,%xmm0");
     367    25630048 :                         asm volatile ("pxor %xmm4,%xmm1");
     368             : 
     369    25630048 :                         asm volatile ("movdqa %xmm4,%xmm5");
     370    25630048 :                         asm volatile ("psrlw  $4,%xmm5");
     371    25630048 :                         asm volatile ("pand   %xmm7,%xmm4");
     372    25630048 :                         asm volatile ("pand   %xmm7,%xmm5");
     373             : 
     374    25630048 :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
     375    25630048 :                         asm volatile ("pshufb %xmm4,%xmm6");
     376    25630048 :                         asm volatile ("pxor   %xmm6,%xmm2");
     377    25630048 :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][1][0]));
     378    25630048 :                         asm volatile ("pshufb %xmm5,%xmm6");
     379    25630048 :                         asm volatile ("pxor   %xmm6,%xmm2");
     380             :                 }
     381             : 
     382             :                 /* first disk with all coefficients at 1 */
     383     4859280 :                 asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
     384             : 
     385     4859280 :                 asm volatile ("pxor %xmm5,%xmm5");
     386     4859280 :                 asm volatile ("pcmpgtb %xmm1,%xmm5");
     387     4859280 :                 asm volatile ("paddb %xmm1,%xmm1");
     388     4859280 :                 asm volatile ("pand %xmm3,%xmm5");
     389     4859280 :                 asm volatile ("pxor %xmm5,%xmm1");
     390             : 
     391     4859280 :                 asm volatile ("pxor %xmm4,%xmm0");
     392     4859280 :                 asm volatile ("pxor %xmm4,%xmm1");
     393     4859280 :                 asm volatile ("pxor %xmm4,%xmm2");
     394             : 
     395     4859280 :                 asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
     396     4859280 :                 asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
     397     4859280 :                 asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
     398             :         }
     399             : 
     400             :         raid_sse_end();
     401             : }
     402             : #endif
     403             : 
     404             : #if defined(CONFIG_X86_64) && defined(CONFIG_SSSE3)
     405             : /*
     406             :  * GEN3 (triple parity with Cauchy matrix) SSSE3 implementation
     407             :  *
     408             :  * Note that it uses 16 registers, meaning that x64 is required.
     409             :  */
     410             : void raid_gen3_ssse3ext(int nd, size_t size, void **vv)
     411             : {
     412             :         uint8_t **v = (uint8_t **)vv;
     413             :         uint8_t *p;
     414             :         uint8_t *q;
     415             :         uint8_t *r;
     416             :         int d, l;
     417             :         size_t i;
     418             : 
     419             :         l = nd - 1;
     420             :         p = v[nd];
     421             :         q = v[nd + 1];
     422             :         r = v[nd + 2];
     423             : 
     424             :         /* special case with only one data disk */
     425             :         if (l == 0) {
     426             :                 for (i = 0; i < 3; ++i)
     427             :                         memcpy(v[1 + i], v[0], size);
     428             :                 return;
     429             :         }
     430             : 
     431             :         raid_sse_begin();
     432             : 
     433             :         /* generic case with at least two data disks */
     434             :         asm volatile ("movdqa %0,%%xmm3" : : "m" (gfconst16.poly[0]));
     435             :         asm volatile ("movdqa %0,%%xmm11" : : "m" (gfconst16.low4[0]));
     436             : 
     437             :         for (i = 0; i < size; i += 32) {
     438             :                 /* last disk without the by two multiplication */
     439             :                 asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
     440             :                 asm volatile ("movdqa %0,%%xmm12" : : "m" (v[l][i + 16]));
     441             : 
     442             :                 asm volatile ("movdqa %xmm4,%xmm0");
     443             :                 asm volatile ("movdqa %xmm4,%xmm1");
     444             :                 asm volatile ("movdqa %xmm12,%xmm8");
     445             :                 asm volatile ("movdqa %xmm12,%xmm9");
     446             : 
     447             :                 asm volatile ("movdqa %xmm4,%xmm5");
     448             :                 asm volatile ("movdqa %xmm12,%xmm13");
     449             :                 asm volatile ("psrlw  $4,%xmm5");
     450             :                 asm volatile ("psrlw  $4,%xmm13");
     451             :                 asm volatile ("pand   %xmm11,%xmm4");
     452             :                 asm volatile ("pand   %xmm11,%xmm12");
     453             :                 asm volatile ("pand   %xmm11,%xmm5");
     454             :                 asm volatile ("pand   %xmm11,%xmm13");
     455             : 
     456             :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
     457             :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
     458             :                 asm volatile ("movdqa %xmm2,%xmm10");
     459             :                 asm volatile ("movdqa %xmm7,%xmm15");
     460             :                 asm volatile ("pshufb %xmm4,%xmm2");
     461             :                 asm volatile ("pshufb %xmm12,%xmm10");
     462             :                 asm volatile ("pshufb %xmm5,%xmm7");
     463             :                 asm volatile ("pshufb %xmm13,%xmm15");
     464             :                 asm volatile ("pxor   %xmm7,%xmm2");
     465             :                 asm volatile ("pxor   %xmm15,%xmm10");
     466             : 
     467             :                 /* intermediate disks */
     468             :                 for (d = l - 1; d > 0; --d) {
     469             :                         asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
     470             :                         asm volatile ("movdqa %0,%%xmm12" : : "m" (v[d][i + 16]));
     471             : 
     472             :                         asm volatile ("pxor %xmm5,%xmm5");
     473             :                         asm volatile ("pxor %xmm13,%xmm13");
     474             :                         asm volatile ("pcmpgtb %xmm1,%xmm5");
     475             :                         asm volatile ("pcmpgtb %xmm9,%xmm13");
     476             :                         asm volatile ("paddb %xmm1,%xmm1");
     477             :                         asm volatile ("paddb %xmm9,%xmm9");
     478             :                         asm volatile ("pand %xmm3,%xmm5");
     479             :                         asm volatile ("pand %xmm3,%xmm13");
     480             :                         asm volatile ("pxor %xmm5,%xmm1");
     481             :                         asm volatile ("pxor %xmm13,%xmm9");
     482             : 
     483             :                         asm volatile ("pxor %xmm4,%xmm0");
     484             :                         asm volatile ("pxor %xmm4,%xmm1");
     485             :                         asm volatile ("pxor %xmm12,%xmm8");
     486             :                         asm volatile ("pxor %xmm12,%xmm9");
     487             : 
     488             :                         asm volatile ("movdqa %xmm4,%xmm5");
     489             :                         asm volatile ("movdqa %xmm12,%xmm13");
     490             :                         asm volatile ("psrlw  $4,%xmm5");
     491             :                         asm volatile ("psrlw  $4,%xmm13");
     492             :                         asm volatile ("pand   %xmm11,%xmm4");
     493             :                         asm volatile ("pand   %xmm11,%xmm12");
     494             :                         asm volatile ("pand   %xmm11,%xmm5");
     495             :                         asm volatile ("pand   %xmm11,%xmm13");
     496             : 
     497             :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
     498             :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
     499             :                         asm volatile ("movdqa %xmm6,%xmm14");
     500             :                         asm volatile ("movdqa %xmm7,%xmm15");
     501             :                         asm volatile ("pshufb %xmm4,%xmm6");
     502             :                         asm volatile ("pshufb %xmm12,%xmm14");
     503             :                         asm volatile ("pshufb %xmm5,%xmm7");
     504             :                         asm volatile ("pshufb %xmm13,%xmm15");
     505             :                         asm volatile ("pxor   %xmm6,%xmm2");
     506             :                         asm volatile ("pxor   %xmm14,%xmm10");
     507             :                         asm volatile ("pxor   %xmm7,%xmm2");
     508             :                         asm volatile ("pxor   %xmm15,%xmm10");
     509             :                 }
     510             : 
     511             :                 /* first disk with all coefficients at 1 */
     512             :                 asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
     513             :                 asm volatile ("movdqa %0,%%xmm12" : : "m" (v[0][i + 16]));
     514             : 
     515             :                 asm volatile ("pxor %xmm5,%xmm5");
     516             :                 asm volatile ("pxor %xmm13,%xmm13");
     517             :                 asm volatile ("pcmpgtb %xmm1,%xmm5");
     518             :                 asm volatile ("pcmpgtb %xmm9,%xmm13");
     519             :                 asm volatile ("paddb %xmm1,%xmm1");
     520             :                 asm volatile ("paddb %xmm9,%xmm9");
     521             :                 asm volatile ("pand %xmm3,%xmm5");
     522             :                 asm volatile ("pand %xmm3,%xmm13");
     523             :                 asm volatile ("pxor %xmm5,%xmm1");
     524             :                 asm volatile ("pxor %xmm13,%xmm9");
     525             : 
     526             :                 asm volatile ("pxor %xmm4,%xmm0");
     527             :                 asm volatile ("pxor %xmm4,%xmm1");
     528             :                 asm volatile ("pxor %xmm4,%xmm2");
     529             :                 asm volatile ("pxor %xmm12,%xmm8");
     530             :                 asm volatile ("pxor %xmm12,%xmm9");
     531             :                 asm volatile ("pxor %xmm12,%xmm10");
     532             : 
     533             :                 asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
     534             :                 asm volatile ("movntdq %%xmm8,%0" : "=m" (p[i + 16]));
     535             :                 asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
     536             :                 asm volatile ("movntdq %%xmm9,%0" : "=m" (q[i + 16]));
     537             :                 asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
     538             :                 asm volatile ("movntdq %%xmm10,%0" : "=m" (r[i + 16]));
     539             :         }
     540             : 
     541             :         raid_sse_end();
     542             : }
     543             : #endif
     544             : 
     545             : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX2)
     546             : /*
     547             :  * GEN3 (triple parity with Cauchy matrix) AVX2 implementation
     548             :  *
     549             :  * Note that it uses 16 registers, meaning that x64 is required.
     550             :  */
     551             : void raid_gen3_avx2ext(int nd, size_t size, void **vv)
     552             : {
     553             :         uint8_t **v = (uint8_t **)vv;
     554             :         uint8_t *p;
     555             :         uint8_t *q;
     556             :         uint8_t *r;
     557             :         int d, l;
     558             :         size_t i;
     559             : 
     560             :         l = nd - 1;
     561             :         p = v[nd];
     562             :         q = v[nd + 1];
     563             :         r = v[nd + 2];
     564             : 
     565             :         /* special case with only one data disk */
     566             :         if (l == 0) {
     567             :                 for (i = 0; i < 3; ++i)
     568             :                         memcpy(v[1 + i], v[0], size);
     569             :                 return;
     570             :         }
     571             : 
     572             :         raid_avx_begin();
     573             : 
     574             :         /* generic case with at least two data disks */
     575             :         asm volatile ("vbroadcasti128 %0, %%ymm3" : : "m" (gfconst16.poly[0]));
     576             :         asm volatile ("vbroadcasti128 %0, %%ymm11" : : "m" (gfconst16.low4[0]));
     577             : 
     578             :         for (i = 0; i < size; i += 64) {
     579             :                 /* last disk without the by two multiplication */
     580             :                 asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[l][i]));
     581             :                 asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[l][i + 32]));
     582             : 
     583             :                 asm volatile ("vmovdqa %ymm4,%ymm0");
     584             :                 asm volatile ("vmovdqa %ymm4,%ymm1");
     585             :                 asm volatile ("vmovdqa %ymm12,%ymm8");
     586             :                 asm volatile ("vmovdqa %ymm12,%ymm9");
     587             : 
     588             :                 asm volatile ("vpsrlw  $4,%ymm4,%ymm5");
     589             :                 asm volatile ("vpsrlw  $4,%ymm12,%ymm13");
     590             :                 asm volatile ("vpand   %ymm11,%ymm4,%ymm4");
     591             :                 asm volatile ("vpand   %ymm11,%ymm12,%ymm12");
     592             :                 asm volatile ("vpand   %ymm11,%ymm5,%ymm5");
     593             :                 asm volatile ("vpand   %ymm11,%ymm13,%ymm13");
     594             : 
     595             :                 asm volatile ("vbroadcasti128 %0,%%ymm10" : : "m" (gfgenpshufb[l][0][0][0]));
     596             :                 asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[l][0][1][0]));
     597             :                 asm volatile ("vpshufb %ymm4,%ymm10,%ymm2");
     598             :                 asm volatile ("vpshufb %ymm12,%ymm10,%ymm10");
     599             :                 asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
     600             :                 asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
     601             :                 asm volatile ("vpxor   %ymm7,%ymm2,%ymm2");
     602             :                 asm volatile ("vpxor   %ymm15,%ymm10,%ymm10");
     603             : 
     604             :                 /* intermediate disks */
     605             :                 for (d = l - 1; d > 0; --d) {
     606             :                         asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
     607             :                         asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[d][i + 32]));
     608             : 
     609             :                         asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
     610             :                         asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
     611             :                         asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
     612             :                         asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
     613             :                         asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
     614             :                         asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
     615             :                         asm volatile ("vpand %ymm3,%ymm5,%ymm5");
     616             :                         asm volatile ("vpand %ymm3,%ymm13,%ymm13");
     617             :                         asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
     618             :                         asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
     619             : 
     620             :                         asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
     621             :                         asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
     622             :                         asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
     623             :                         asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
     624             : 
     625             :                         asm volatile ("vpsrlw  $4,%ymm4,%ymm5");
     626             :                         asm volatile ("vpsrlw  $4,%ymm12,%ymm13");
     627             :                         asm volatile ("vpand   %ymm11,%ymm4,%ymm4");
     628             :                         asm volatile ("vpand   %ymm11,%ymm12,%ymm12");
     629             :                         asm volatile ("vpand   %ymm11,%ymm5,%ymm5");
     630             :                         asm volatile ("vpand   %ymm11,%ymm13,%ymm13");
     631             : 
     632             :                         asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfgenpshufb[d][0][0][0]));
     633             :                         asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[d][0][1][0]));
     634             :                         asm volatile ("vpshufb %ymm4,%ymm14,%ymm6");
     635             :                         asm volatile ("vpshufb %ymm12,%ymm14,%ymm14");
     636             :                         asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
     637             :                         asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
     638             :                         asm volatile ("vpxor   %ymm6,%ymm2,%ymm2");
     639             :                         asm volatile ("vpxor   %ymm14,%ymm10,%ymm10");
     640             :                         asm volatile ("vpxor   %ymm7,%ymm2,%ymm2");
     641             :                         asm volatile ("vpxor   %ymm15,%ymm10,%ymm10");
     642             :                 }
     643             : 
     644             :                 /* first disk with all coefficients at 1 */
     645             :                 asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[0][i]));
     646             :                 asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[0][i + 32]));
     647             : 
     648             :                 asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
     649             :                 asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
     650             :                 asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
     651             :                 asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
     652             :                 asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
     653             :                 asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
     654             :                 asm volatile ("vpand %ymm3,%ymm5,%ymm5");
     655             :                 asm volatile ("vpand %ymm3,%ymm13,%ymm13");
     656             :                 asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
     657             :                 asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
     658             : 
     659             :                 asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
     660             :                 asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
     661             :                 asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
     662             :                 asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
     663             :                 asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
     664             :                 asm volatile ("vpxor %ymm12,%ymm10,%ymm10");
     665             : 
     666             :                 asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
     667             :                 asm volatile ("vmovntdq %%ymm8,%0" : "=m" (p[i + 32]));
     668             :                 asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
     669             :                 asm volatile ("vmovntdq %%ymm9,%0" : "=m" (q[i + 32]));
     670             :                 asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
     671             :                 asm volatile ("vmovntdq %%ymm10,%0" : "=m" (r[i + 32]));
     672             :         }
     673             : 
     674             :         raid_avx_end();
     675             : }
     676             : #endif
     677             : 
     678             : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
     679             : /*
     680             :  * GEN4 (quad parity with Cauchy matrix) SSSE3 implementation
     681             :  */
     682       32469 : void raid_gen4_ssse3(int nd, size_t size, void **vv)
     683             : {
     684       32469 :         uint8_t **v = (uint8_t **)vv;
     685             :         uint8_t *p;
     686             :         uint8_t *q;
     687             :         uint8_t *r;
     688             :         uint8_t *s;
     689             :         int d, l;
     690             :         size_t i;
     691             : 
     692       32469 :         l = nd - 1;
     693       32469 :         p = v[nd];
     694       32469 :         q = v[nd + 1];
     695       32469 :         r = v[nd + 2];
     696       32469 :         s = v[nd + 3];
     697             : 
     698             :         /* special case with only one data disk */
     699       32469 :         if (l == 0) {
     700           5 :                 for (i = 0; i < 4; ++i)
     701           4 :                         memcpy(v[1 + i], v[0], size);
     702       32470 :                 return;
     703             :         }
     704             : 
     705             :         raid_sse_begin();
     706             : 
     707             :         /* generic case with at least two data disks */
     708     3334804 :         for (i = 0; i < size; i += 16) {
     709             :                 /* last disk without the by two multiplication */
     710     3302336 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
     711     3302336 :                 asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
     712             : 
     713     3302336 :                 asm volatile ("movdqa %xmm4,%xmm0");
     714     3302336 :                 asm volatile ("movdqa %xmm4,%xmm1");
     715             : 
     716     3302336 :                 asm volatile ("movdqa %xmm4,%xmm5");
     717     3302336 :                 asm volatile ("psrlw  $4,%xmm5");
     718     3302336 :                 asm volatile ("pand   %xmm7,%xmm4");
     719     3302336 :                 asm volatile ("pand   %xmm7,%xmm5");
     720             : 
     721     3302336 :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
     722     3302336 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
     723     3302336 :                 asm volatile ("pshufb %xmm4,%xmm2");
     724     3302336 :                 asm volatile ("pshufb %xmm5,%xmm7");
     725     3302336 :                 asm volatile ("pxor   %xmm7,%xmm2");
     726             : 
     727     3302336 :                 asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
     728     3302336 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
     729     3302336 :                 asm volatile ("pshufb %xmm4,%xmm3");
     730     3302336 :                 asm volatile ("pshufb %xmm5,%xmm7");
     731     3302336 :                 asm volatile ("pxor   %xmm7,%xmm3");
     732             : 
     733             :                 /* intermediate disks */
     734    19771392 :                 for (d = l - 1; d > 0; --d) {
     735    16469056 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
     736    16469056 :                         asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
     737             : 
     738    16469056 :                         asm volatile ("pxor %xmm5,%xmm5");
     739    16469056 :                         asm volatile ("pcmpgtb %xmm1,%xmm5");
     740    16469056 :                         asm volatile ("paddb %xmm1,%xmm1");
     741    16469056 :                         asm volatile ("pand %xmm7,%xmm5");
     742    16469056 :                         asm volatile ("pxor %xmm5,%xmm1");
     743             : 
     744    16469056 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
     745             : 
     746    16469056 :                         asm volatile ("pxor %xmm4,%xmm0");
     747    16469056 :                         asm volatile ("pxor %xmm4,%xmm1");
     748             : 
     749    16469056 :                         asm volatile ("movdqa %xmm4,%xmm5");
     750    16469056 :                         asm volatile ("psrlw  $4,%xmm5");
     751    16469056 :                         asm volatile ("pand   %xmm7,%xmm4");
     752    16469056 :                         asm volatile ("pand   %xmm7,%xmm5");
     753             : 
     754    16469056 :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
     755    16469056 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
     756    16469056 :                         asm volatile ("pshufb %xmm4,%xmm6");
     757    16469056 :                         asm volatile ("pshufb %xmm5,%xmm7");
     758    16469056 :                         asm volatile ("pxor   %xmm6,%xmm2");
     759    16469056 :                         asm volatile ("pxor   %xmm7,%xmm2");
     760             : 
     761    16469056 :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
     762    16469056 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
     763    16469056 :                         asm volatile ("pshufb %xmm4,%xmm6");
     764    16469056 :                         asm volatile ("pshufb %xmm5,%xmm7");
     765    16469056 :                         asm volatile ("pxor   %xmm6,%xmm3");
     766    16469056 :                         asm volatile ("pxor   %xmm7,%xmm3");
     767             :                 }
     768             : 
     769             :                 /* first disk with all coefficients at 1 */
     770     3302336 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
     771     3302336 :                 asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
     772             : 
     773     3302336 :                 asm volatile ("pxor %xmm5,%xmm5");
     774     3302336 :                 asm volatile ("pcmpgtb %xmm1,%xmm5");
     775     3302336 :                 asm volatile ("paddb %xmm1,%xmm1");
     776     3302336 :                 asm volatile ("pand %xmm7,%xmm5");
     777     3302336 :                 asm volatile ("pxor %xmm5,%xmm1");
     778             : 
     779     3302336 :                 asm volatile ("pxor %xmm4,%xmm0");
     780     3302336 :                 asm volatile ("pxor %xmm4,%xmm1");
     781     3302336 :                 asm volatile ("pxor %xmm4,%xmm2");
     782     3302336 :                 asm volatile ("pxor %xmm4,%xmm3");
     783             : 
     784     3302336 :                 asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
     785     3302336 :                 asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
     786     3302336 :                 asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
     787     3302336 :                 asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
     788             :         }
     789             : 
     790             :         raid_sse_end();
     791             : }
     792             : #endif
     793             : 
     794             : #if defined(CONFIG_X86_64) && defined(CONFIG_SSSE3)
     795             : /*
     796             :  * GEN4 (quad parity with Cauchy matrix) SSSE3 implementation
     797             :  *
     798             :  * Note that it uses 16 registers, meaning that x64 is required.
     799             :  */
     800             : void raid_gen4_ssse3ext(int nd, size_t size, void **vv)
     801             : {
     802             :         uint8_t **v = (uint8_t **)vv;
     803             :         uint8_t *p;
     804             :         uint8_t *q;
     805             :         uint8_t *r;
     806             :         uint8_t *s;
     807             :         int d, l;
     808             :         size_t i;
     809             : 
     810             :         l = nd - 1;
     811             :         p = v[nd];
     812             :         q = v[nd + 1];
     813             :         r = v[nd + 2];
     814             :         s = v[nd + 3];
     815             : 
     816             :         /* special case with only one data disk */
     817             :         if (l == 0) {
     818             :                 for (i = 0; i < 4; ++i)
     819             :                         memcpy(v[1 + i], v[0], size);
     820             :                 return;
     821             :         }
     822             : 
     823             :         raid_sse_begin();
     824             : 
     825             :         /* generic case with at least two data disks */
     826             :         for (i = 0; i < size; i += 32) {
     827             :                 /* last disk without the by two multiplication */
     828             :                 asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
     829             :                 asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
     830             :                 asm volatile ("movdqa %0,%%xmm12" : : "m" (v[l][i + 16]));
     831             : 
     832             :                 asm volatile ("movdqa %xmm4,%xmm0");
     833             :                 asm volatile ("movdqa %xmm4,%xmm1");
     834             :                 asm volatile ("movdqa %xmm12,%xmm8");
     835             :                 asm volatile ("movdqa %xmm12,%xmm9");
     836             : 
     837             :                 asm volatile ("movdqa %xmm4,%xmm5");
     838             :                 asm volatile ("movdqa %xmm12,%xmm13");
     839             :                 asm volatile ("psrlw  $4,%xmm5");
     840             :                 asm volatile ("psrlw  $4,%xmm13");
     841             :                 asm volatile ("pand   %xmm15,%xmm4");
     842             :                 asm volatile ("pand   %xmm15,%xmm12");
     843             :                 asm volatile ("pand   %xmm15,%xmm5");
     844             :                 asm volatile ("pand   %xmm15,%xmm13");
     845             : 
     846             :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
     847             :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
     848             :                 asm volatile ("movdqa %xmm2,%xmm10");
     849             :                 asm volatile ("movdqa %xmm7,%xmm15");
     850             :                 asm volatile ("pshufb %xmm4,%xmm2");
     851             :                 asm volatile ("pshufb %xmm12,%xmm10");
     852             :                 asm volatile ("pshufb %xmm5,%xmm7");
     853             :                 asm volatile ("pshufb %xmm13,%xmm15");
     854             :                 asm volatile ("pxor   %xmm7,%xmm2");
     855             :                 asm volatile ("pxor   %xmm15,%xmm10");
     856             : 
     857             :                 asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
     858             :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
     859             :                 asm volatile ("movdqa %xmm3,%xmm11");
     860             :                 asm volatile ("movdqa %xmm7,%xmm15");
     861             :                 asm volatile ("pshufb %xmm4,%xmm3");
     862             :                 asm volatile ("pshufb %xmm12,%xmm11");
     863             :                 asm volatile ("pshufb %xmm5,%xmm7");
     864             :                 asm volatile ("pshufb %xmm13,%xmm15");
     865             :                 asm volatile ("pxor   %xmm7,%xmm3");
     866             :                 asm volatile ("pxor   %xmm15,%xmm11");
     867             : 
     868             :                 /* intermediate disks */
     869             :                 for (d = l - 1; d > 0; --d) {
     870             :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
     871             :                         asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
     872             :                         asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
     873             :                         asm volatile ("movdqa %0,%%xmm12" : : "m" (v[d][i + 16]));
     874             : 
     875             :                         asm volatile ("pxor %xmm5,%xmm5");
     876             :                         asm volatile ("pxor %xmm13,%xmm13");
     877             :                         asm volatile ("pcmpgtb %xmm1,%xmm5");
     878             :                         asm volatile ("pcmpgtb %xmm9,%xmm13");
     879             :                         asm volatile ("paddb %xmm1,%xmm1");
     880             :                         asm volatile ("paddb %xmm9,%xmm9");
     881             :                         asm volatile ("pand %xmm7,%xmm5");
     882             :                         asm volatile ("pand %xmm7,%xmm13");
     883             :                         asm volatile ("pxor %xmm5,%xmm1");
     884             :                         asm volatile ("pxor %xmm13,%xmm9");
     885             : 
     886             :                         asm volatile ("pxor %xmm4,%xmm0");
     887             :                         asm volatile ("pxor %xmm4,%xmm1");
     888             :                         asm volatile ("pxor %xmm12,%xmm8");
     889             :                         asm volatile ("pxor %xmm12,%xmm9");
     890             : 
     891             :                         asm volatile ("movdqa %xmm4,%xmm5");
     892             :                         asm volatile ("movdqa %xmm12,%xmm13");
     893             :                         asm volatile ("psrlw  $4,%xmm5");
     894             :                         asm volatile ("psrlw  $4,%xmm13");
     895             :                         asm volatile ("pand   %xmm15,%xmm4");
     896             :                         asm volatile ("pand   %xmm15,%xmm12");
     897             :                         asm volatile ("pand   %xmm15,%xmm5");
     898             :                         asm volatile ("pand   %xmm15,%xmm13");
     899             : 
     900             :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
     901             :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
     902             :                         asm volatile ("movdqa %xmm6,%xmm14");
     903             :                         asm volatile ("movdqa %xmm7,%xmm15");
     904             :                         asm volatile ("pshufb %xmm4,%xmm6");
     905             :                         asm volatile ("pshufb %xmm12,%xmm14");
     906             :                         asm volatile ("pshufb %xmm5,%xmm7");
     907             :                         asm volatile ("pshufb %xmm13,%xmm15");
     908             :                         asm volatile ("pxor   %xmm6,%xmm2");
     909             :                         asm volatile ("pxor   %xmm14,%xmm10");
     910             :                         asm volatile ("pxor   %xmm7,%xmm2");
     911             :                         asm volatile ("pxor   %xmm15,%xmm10");
     912             : 
     913             :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
     914             :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
     915             :                         asm volatile ("movdqa %xmm6,%xmm14");
     916             :                         asm volatile ("movdqa %xmm7,%xmm15");
     917             :                         asm volatile ("pshufb %xmm4,%xmm6");
     918             :                         asm volatile ("pshufb %xmm12,%xmm14");
     919             :                         asm volatile ("pshufb %xmm5,%xmm7");
     920             :                         asm volatile ("pshufb %xmm13,%xmm15");
     921             :                         asm volatile ("pxor   %xmm6,%xmm3");
     922             :                         asm volatile ("pxor   %xmm14,%xmm11");
     923             :                         asm volatile ("pxor   %xmm7,%xmm3");
     924             :                         asm volatile ("pxor   %xmm15,%xmm11");
     925             :                 }
     926             : 
     927             :                 /* first disk with all coefficients at 1 */
     928             :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
     929             :                 asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
     930             :                 asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
     931             :                 asm volatile ("movdqa %0,%%xmm12" : : "m" (v[0][i + 16]));
     932             : 
     933             :                 asm volatile ("pxor %xmm5,%xmm5");
     934             :                 asm volatile ("pxor %xmm13,%xmm13");
     935             :                 asm volatile ("pcmpgtb %xmm1,%xmm5");
     936             :                 asm volatile ("pcmpgtb %xmm9,%xmm13");
     937             :                 asm volatile ("paddb %xmm1,%xmm1");
     938             :                 asm volatile ("paddb %xmm9,%xmm9");
     939             :                 asm volatile ("pand %xmm7,%xmm5");
     940             :                 asm volatile ("pand %xmm7,%xmm13");
     941             :                 asm volatile ("pxor %xmm5,%xmm1");
     942             :                 asm volatile ("pxor %xmm13,%xmm9");
     943             : 
     944             :                 asm volatile ("pxor %xmm4,%xmm0");
     945             :                 asm volatile ("pxor %xmm4,%xmm1");
     946             :                 asm volatile ("pxor %xmm4,%xmm2");
     947             :                 asm volatile ("pxor %xmm4,%xmm3");
     948             :                 asm volatile ("pxor %xmm12,%xmm8");
     949             :                 asm volatile ("pxor %xmm12,%xmm9");
     950             :                 asm volatile ("pxor %xmm12,%xmm10");
     951             :                 asm volatile ("pxor %xmm12,%xmm11");
     952             : 
     953             :                 asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
     954             :                 asm volatile ("movntdq %%xmm8,%0" : "=m" (p[i + 16]));
     955             :                 asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
     956             :                 asm volatile ("movntdq %%xmm9,%0" : "=m" (q[i + 16]));
     957             :                 asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
     958             :                 asm volatile ("movntdq %%xmm10,%0" : "=m" (r[i + 16]));
     959             :                 asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
     960             :                 asm volatile ("movntdq %%xmm11,%0" : "=m" (s[i + 16]));
     961             :         }
     962             : 
     963             :         raid_sse_end();
     964             : }
     965             : #endif
     966             : 
     967             : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX2)
     968             : /*
     969             :  * GEN4 (quad parity with Cauchy matrix) AVX2 implementation
     970             :  *
     971             :  * Note that it uses 16 registers, meaning that x64 is required.
     972             :  */
     973             : void raid_gen4_avx2ext(int nd, size_t size, void **vv)
     974             : {
     975             :         uint8_t **v = (uint8_t **)vv;
     976             :         uint8_t *p;
     977             :         uint8_t *q;
     978             :         uint8_t *r;
     979             :         uint8_t *s;
     980             :         int d, l;
     981             :         size_t i;
     982             : 
     983             :         l = nd - 1;
     984             :         p = v[nd];
     985             :         q = v[nd + 1];
     986             :         r = v[nd + 2];
     987             :         s = v[nd + 3];
     988             : 
     989             :         /* special case with only one data disk */
     990             :         if (l == 0) {
     991             :                 for (i = 0; i < 4; ++i)
     992             :                         memcpy(v[1 + i], v[0], size);
     993             :                 return;
     994             :         }
     995             : 
     996             :         raid_avx_begin();
     997             : 
     998             :         /* generic case with at least two data disks */
     999             :         for (i = 0; i < size; i += 64) {
    1000             :                 /* last disk without the by two multiplication */
    1001             :                 asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
    1002             :                 asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[l][i]));
    1003             :                 asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[l][i + 32]));
    1004             : 
    1005             :                 asm volatile ("vmovdqa %ymm4,%ymm0");
    1006             :                 asm volatile ("vmovdqa %ymm4,%ymm1");
    1007             :                 asm volatile ("vmovdqa %ymm12,%ymm8");
    1008             :                 asm volatile ("vmovdqa %ymm12,%ymm9");
    1009             : 
    1010             :                 asm volatile ("vpsrlw  $4,%ymm4,%ymm5");
    1011             :                 asm volatile ("vpsrlw  $4,%ymm12,%ymm13");
    1012             :                 asm volatile ("vpand   %ymm15,%ymm4,%ymm4");
    1013             :                 asm volatile ("vpand   %ymm15,%ymm12,%ymm12");
    1014             :                 asm volatile ("vpand   %ymm15,%ymm5,%ymm5");
    1015             :                 asm volatile ("vpand   %ymm15,%ymm13,%ymm13");
    1016             : 
    1017             :                 asm volatile ("vbroadcasti128 %0,%%ymm10" : : "m" (gfgenpshufb[l][0][0][0]));
    1018             :                 asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[l][0][1][0]));
    1019             :                 asm volatile ("vpshufb %ymm4,%ymm10,%ymm2");
    1020             :                 asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
    1021             :                 asm volatile ("vpshufb %ymm12,%ymm10,%ymm10");
    1022             :                 asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
    1023             :                 asm volatile ("vpxor   %ymm7,%ymm2,%ymm2");
    1024             :                 asm volatile ("vpxor   %ymm15,%ymm10,%ymm10");
    1025             : 
    1026             :                 asm volatile ("vbroadcasti128 %0,%%ymm11" : : "m" (gfgenpshufb[l][1][0][0]));
    1027             :                 asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[l][1][1][0]));
    1028             :                 asm volatile ("vpshufb %ymm4,%ymm11,%ymm3");
    1029             :                 asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
    1030             :                 asm volatile ("vpshufb %ymm12,%ymm11,%ymm11");
    1031             :                 asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
    1032             :                 asm volatile ("vpxor   %ymm7,%ymm3,%ymm3");
    1033             :                 asm volatile ("vpxor   %ymm15,%ymm11,%ymm11");
    1034             : 
    1035             :                 /* intermediate disks */
    1036             :                 for (d = l - 1; d > 0; --d) {
    1037             :                         asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.poly[0]));
    1038             :                         asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
    1039             :                         asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
    1040             :                         asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[d][i + 32]));
    1041             : 
    1042             :                         asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
    1043             :                         asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
    1044             :                         asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
    1045             :                         asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
    1046             :                         asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
    1047             :                         asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
    1048             :                         asm volatile ("vpand %ymm7,%ymm5,%ymm5");
    1049             :                         asm volatile ("vpand %ymm7,%ymm13,%ymm13");
    1050             :                         asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
    1051             :                         asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
    1052             : 
    1053             :                         asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
    1054             :                         asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
    1055             :                         asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
    1056             :                         asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
    1057             : 
    1058             :                         asm volatile ("vpsrlw  $4,%ymm4,%ymm5");
    1059             :                         asm volatile ("vpsrlw  $4,%ymm12,%ymm13");
    1060             :                         asm volatile ("vpand   %ymm15,%ymm4,%ymm4");
    1061             :                         asm volatile ("vpand   %ymm15,%ymm12,%ymm12");
    1062             :                         asm volatile ("vpand   %ymm15,%ymm5,%ymm5");
    1063             :                         asm volatile ("vpand   %ymm15,%ymm13,%ymm13");
    1064             : 
    1065             :                         asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfgenpshufb[d][0][0][0]));
    1066             :                         asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[d][0][1][0]));
    1067             :                         asm volatile ("vpshufb %ymm4,%ymm14,%ymm6");
    1068             :                         asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
    1069             :                         asm volatile ("vpshufb %ymm12,%ymm14,%ymm14");
    1070             :                         asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
    1071             :                         asm volatile ("vpxor   %ymm6,%ymm2,%ymm2");
    1072             :                         asm volatile ("vpxor   %ymm14,%ymm10,%ymm10");
    1073             :                         asm volatile ("vpxor   %ymm7,%ymm2,%ymm2");
    1074             :                         asm volatile ("vpxor   %ymm15,%ymm10,%ymm10");
    1075             : 
    1076             :                         asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfgenpshufb[d][1][0][0]));
    1077             :                         asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[d][1][1][0]));
    1078             :                         asm volatile ("vpshufb %ymm4,%ymm14,%ymm6");
    1079             :                         asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
    1080             :                         asm volatile ("vpshufb %ymm12,%ymm14,%ymm14");
    1081             :                         asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
    1082             :                         asm volatile ("vpxor   %ymm6,%ymm3,%ymm3");
    1083             :                         asm volatile ("vpxor   %ymm14,%ymm11,%ymm11");
    1084             :                         asm volatile ("vpxor   %ymm7,%ymm3,%ymm3");
    1085             :                         asm volatile ("vpxor   %ymm15,%ymm11,%ymm11");
    1086             :                 }
    1087             : 
    1088             :                 /* first disk with all coefficients at 1 */
    1089             :                 asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.poly[0]));
    1090             :                 asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
    1091             :                 asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[0][i]));
    1092             :                 asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[0][i + 32]));
    1093             : 
    1094             :                 asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
    1095             :                 asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
    1096             :                 asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
    1097             :                 asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
    1098             :                 asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
    1099             :                 asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
    1100             :                 asm volatile ("vpand %ymm7,%ymm5,%ymm5");
    1101             :                 asm volatile ("vpand %ymm7,%ymm13,%ymm13");
    1102             :                 asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
    1103             :                 asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
    1104             : 
    1105             :                 asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
    1106             :                 asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
    1107             :                 asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
    1108             :                 asm volatile ("vpxor %ymm4,%ymm3,%ymm3");
    1109             :                 asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
    1110             :                 asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
    1111             :                 asm volatile ("vpxor %ymm12,%ymm10,%ymm10");
    1112             :                 asm volatile ("vpxor %ymm12,%ymm11,%ymm11");
    1113             : 
    1114             :                 asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
    1115             :                 asm volatile ("vmovntdq %%ymm8,%0" : "=m" (p[i + 32]));
    1116             :                 asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
    1117             :                 asm volatile ("vmovntdq %%ymm9,%0" : "=m" (q[i + 32]));
    1118             :                 asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
    1119             :                 asm volatile ("vmovntdq %%ymm10,%0" : "=m" (r[i + 32]));
    1120             :                 asm volatile ("vmovntdq %%ymm3,%0" : "=m" (s[i]));
    1121             :                 asm volatile ("vmovntdq %%ymm11,%0" : "=m" (s[i + 32]));
    1122             :         }
    1123             : 
    1124             :         raid_avx_end();
    1125             : }
    1126             : #endif
    1127             : 
    1128             : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
    1129             : /*
    1130             :  * GEN5 (penta parity with Cauchy matrix) SSSE3 implementation
    1131             :  */
    1132       50654 : void raid_gen5_ssse3(int nd, size_t size, void **vv)
    1133             : {
    1134       50654 :         uint8_t **v = (uint8_t **)vv;
    1135             :         uint8_t *p;
    1136             :         uint8_t *q;
    1137             :         uint8_t *r;
    1138             :         uint8_t *s;
    1139             :         uint8_t *t;
    1140             :         int d, l;
    1141             :         size_t i;
    1142             :         uint8_t buffer[16+16];
    1143       50654 :         uint8_t *pd = __align_ptr(buffer, 16);
    1144             : 
    1145       50654 :         l = nd - 1;
    1146       50654 :         p = v[nd];
    1147       50654 :         q = v[nd + 1];
    1148       50654 :         r = v[nd + 2];
    1149       50654 :         s = v[nd + 3];
    1150       50654 :         t = v[nd + 4];
    1151             : 
    1152             :         /* special case with only one data disk */
    1153       50654 :         if (l == 0) {
    1154           6 :                 for (i = 0; i < 5; ++i)
    1155           5 :                         memcpy(v[1 + i], v[0], size);
    1156       50655 :                 return;
    1157             :         }
    1158             : 
    1159             :         raid_sse_begin();
    1160             : 
    1161             :         /* generic case with at least two data disks */
    1162     3937517 :         for (i = 0; i < size; i += 16) {
    1163             :                 /* last disk without the by two multiplication */
    1164     3886864 :                 asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
    1165             : 
    1166     3886864 :                 asm volatile ("movdqa %xmm4,%xmm0");
    1167     3886864 :                 asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[0]));
    1168             : 
    1169     3886864 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
    1170     3886864 :                 asm volatile ("movdqa %xmm4,%xmm5");
    1171     3886864 :                 asm volatile ("psrlw  $4,%xmm5");
    1172     3886864 :                 asm volatile ("pand   %xmm7,%xmm4");
    1173     3886864 :                 asm volatile ("pand   %xmm7,%xmm5");
    1174             : 
    1175     3886864 :                 asm volatile ("movdqa %0,%%xmm1" : : "m" (gfgenpshufb[l][0][0][0]));
    1176     3886864 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
    1177     3886864 :                 asm volatile ("pshufb %xmm4,%xmm1");
    1178     3886864 :                 asm volatile ("pshufb %xmm5,%xmm7");
    1179     3886864 :                 asm volatile ("pxor   %xmm7,%xmm1");
    1180             : 
    1181     3886864 :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][1][0][0]));
    1182     3886864 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
    1183     3886864 :                 asm volatile ("pshufb %xmm4,%xmm2");
    1184     3886864 :                 asm volatile ("pshufb %xmm5,%xmm7");
    1185     3886864 :                 asm volatile ("pxor   %xmm7,%xmm2");
    1186             : 
    1187     3886864 :                 asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][2][0][0]));
    1188     3886864 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][2][1][0]));
    1189     3886864 :                 asm volatile ("pshufb %xmm4,%xmm3");
    1190     3886864 :                 asm volatile ("pshufb %xmm5,%xmm7");
    1191     3886864 :                 asm volatile ("pxor   %xmm7,%xmm3");
    1192             : 
    1193             :                 /* intermediate disks */
    1194    23263984 :                 for (d = l - 1; d > 0; --d) {
    1195    19377120 :                         asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
    1196    19377120 :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[0]));
    1197    19377120 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
    1198             : 
    1199    19377120 :                         asm volatile ("pxor %xmm5,%xmm5");
    1200    19377120 :                         asm volatile ("pcmpgtb %xmm0,%xmm5");
    1201    19377120 :                         asm volatile ("paddb %xmm0,%xmm0");
    1202    19377120 :                         asm volatile ("pand %xmm7,%xmm5");
    1203    19377120 :                         asm volatile ("pxor %xmm5,%xmm0");
    1204             : 
    1205    19377120 :                         asm volatile ("pxor %xmm4,%xmm0");
    1206    19377120 :                         asm volatile ("pxor %xmm4,%xmm6");
    1207    19377120 :                         asm volatile ("movdqa %%xmm6,%0" : "=m" (pd[0]));
    1208             : 
    1209    19377120 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
    1210    19377120 :                         asm volatile ("movdqa %xmm4,%xmm5");
    1211    19377120 :                         asm volatile ("psrlw  $4,%xmm5");
    1212    19377120 :                         asm volatile ("pand   %xmm7,%xmm4");
    1213    19377120 :                         asm volatile ("pand   %xmm7,%xmm5");
    1214             : 
    1215    19377120 :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
    1216    19377120 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
    1217    19377120 :                         asm volatile ("pshufb %xmm4,%xmm6");
    1218    19377120 :                         asm volatile ("pshufb %xmm5,%xmm7");
    1219    19377120 :                         asm volatile ("pxor   %xmm6,%xmm1");
    1220    19377120 :                         asm volatile ("pxor   %xmm7,%xmm1");
    1221             : 
    1222    19377120 :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
    1223    19377120 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
    1224    19377120 :                         asm volatile ("pshufb %xmm4,%xmm6");
    1225    19377120 :                         asm volatile ("pshufb %xmm5,%xmm7");
    1226    19377120 :                         asm volatile ("pxor   %xmm6,%xmm2");
    1227    19377120 :                         asm volatile ("pxor   %xmm7,%xmm2");
    1228             : 
    1229    19377120 :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][2][0][0]));
    1230    19377120 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][2][1][0]));
    1231    19377120 :                         asm volatile ("pshufb %xmm4,%xmm6");
    1232    19377120 :                         asm volatile ("pshufb %xmm5,%xmm7");
    1233    19377120 :                         asm volatile ("pxor   %xmm6,%xmm3");
    1234    19377120 :                         asm volatile ("pxor   %xmm7,%xmm3");
    1235             :                 }
    1236             : 
    1237             :                 /* first disk with all coefficients at 1 */
    1238     3886864 :                 asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
    1239     3886864 :                 asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[0]));
    1240     3886864 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
    1241             : 
    1242     3886864 :                 asm volatile ("pxor %xmm5,%xmm5");
    1243     3886864 :                 asm volatile ("pcmpgtb %xmm0,%xmm5");
    1244     3886864 :                 asm volatile ("paddb %xmm0,%xmm0");
    1245     3886864 :                 asm volatile ("pand %xmm7,%xmm5");
    1246     3886864 :                 asm volatile ("pxor %xmm5,%xmm0");
    1247             : 
    1248     3886864 :                 asm volatile ("pxor %xmm4,%xmm0");
    1249     3886864 :                 asm volatile ("pxor %xmm4,%xmm1");
    1250     3886864 :                 asm volatile ("pxor %xmm4,%xmm2");
    1251     3886864 :                 asm volatile ("pxor %xmm4,%xmm3");
    1252     3886864 :                 asm volatile ("pxor %xmm4,%xmm6");
    1253             : 
    1254     3886864 :                 asm volatile ("movntdq %%xmm6,%0" : "=m" (p[i]));
    1255     3886864 :                 asm volatile ("movntdq %%xmm0,%0" : "=m" (q[i]));
    1256     3886864 :                 asm volatile ("movntdq %%xmm1,%0" : "=m" (r[i]));
    1257     3886864 :                 asm volatile ("movntdq %%xmm2,%0" : "=m" (s[i]));
    1258     3886864 :                 asm volatile ("movntdq %%xmm3,%0" : "=m" (t[i]));
    1259             :         }
    1260             : 
    1261             :         raid_sse_end();
    1262             : }
    1263             : #endif
    1264             : 
    1265             : #if defined(CONFIG_X86_64) && defined(CONFIG_SSSE3)
    1266             : /*
    1267             :  * GEN5 (penta parity with Cauchy matrix) SSSE3 implementation
    1268             :  *
    1269             :  * Note that it uses 16 registers, meaning that x64 is required.
    1270             :  */
    1271             : void raid_gen5_ssse3ext(int nd, size_t size, void **vv)
    1272             : {
    1273             :         uint8_t **v = (uint8_t **)vv;
    1274             :         uint8_t *p;
    1275             :         uint8_t *q;
    1276             :         uint8_t *r;
    1277             :         uint8_t *s;
    1278             :         uint8_t *t;
    1279             :         int d, l;
    1280             :         size_t i;
    1281             : 
    1282             :         l = nd - 1;
    1283             :         p = v[nd];
    1284             :         q = v[nd + 1];
    1285             :         r = v[nd + 2];
    1286             :         s = v[nd + 3];
    1287             :         t = v[nd + 4];
    1288             : 
    1289             :         /* special case with only one data disk */
    1290             :         if (l == 0) {
    1291             :                 for (i = 0; i < 5; ++i)
    1292             :                         memcpy(v[1 + i], v[0], size);
    1293             :                 return;
    1294             :         }
    1295             : 
    1296             :         raid_sse_begin();
    1297             : 
    1298             :         /* generic case with at least two data disks */
    1299             :         asm volatile ("movdqa %0,%%xmm14" : : "m" (gfconst16.poly[0]));
    1300             :         asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
    1301             : 
    1302             :         for (i = 0; i < size; i += 16) {
    1303             :                 /* last disk without the by two multiplication */
    1304             :                 asm volatile ("movdqa %0,%%xmm10" : : "m" (v[l][i]));
    1305             : 
    1306             :                 asm volatile ("movdqa %xmm10,%xmm0");
    1307             :                 asm volatile ("movdqa %xmm10,%xmm1");
    1308             : 
    1309             :                 asm volatile ("movdqa %xmm10,%xmm11");
    1310             :                 asm volatile ("psrlw  $4,%xmm11");
    1311             :                 asm volatile ("pand   %xmm15,%xmm10");
    1312             :                 asm volatile ("pand   %xmm15,%xmm11");
    1313             : 
    1314             :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
    1315             :                 asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][0][1][0]));
    1316             :                 asm volatile ("pshufb %xmm10,%xmm2");
    1317             :                 asm volatile ("pshufb %xmm11,%xmm13");
    1318             :                 asm volatile ("pxor   %xmm13,%xmm2");
    1319             : 
    1320             :                 asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
    1321             :                 asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][1][1][0]));
    1322             :                 asm volatile ("pshufb %xmm10,%xmm3");
    1323             :                 asm volatile ("pshufb %xmm11,%xmm13");
    1324             :                 asm volatile ("pxor   %xmm13,%xmm3");
    1325             : 
    1326             :                 asm volatile ("movdqa %0,%%xmm4" : : "m" (gfgenpshufb[l][2][0][0]));
    1327             :                 asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][2][1][0]));
    1328             :                 asm volatile ("pshufb %xmm10,%xmm4");
    1329             :                 asm volatile ("pshufb %xmm11,%xmm13");
    1330             :                 asm volatile ("pxor   %xmm13,%xmm4");
    1331             : 
    1332             :                 /* intermediate disks */
    1333             :                 for (d = l - 1; d > 0; --d) {
    1334             :                         asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i]));
    1335             : 
    1336             :                         asm volatile ("pxor %xmm11,%xmm11");
    1337             :                         asm volatile ("pcmpgtb %xmm1,%xmm11");
    1338             :                         asm volatile ("paddb %xmm1,%xmm1");
    1339             :                         asm volatile ("pand %xmm14,%xmm11");
    1340             :                         asm volatile ("pxor %xmm11,%xmm1");
    1341             : 
    1342             :                         asm volatile ("pxor %xmm10,%xmm0");
    1343             :                         asm volatile ("pxor %xmm10,%xmm1");
    1344             : 
    1345             :                         asm volatile ("movdqa %xmm10,%xmm11");
    1346             :                         asm volatile ("psrlw  $4,%xmm11");
    1347             :                         asm volatile ("pand   %xmm15,%xmm10");
    1348             :                         asm volatile ("pand   %xmm15,%xmm11");
    1349             : 
    1350             :                         asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][0][0][0]));
    1351             :                         asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][0][1][0]));
    1352             :                         asm volatile ("pshufb %xmm10,%xmm12");
    1353             :                         asm volatile ("pshufb %xmm11,%xmm13");
    1354             :                         asm volatile ("pxor   %xmm12,%xmm2");
    1355             :                         asm volatile ("pxor   %xmm13,%xmm2");
    1356             : 
    1357             :                         asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][1][0][0]));
    1358             :                         asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][1][1][0]));
    1359             :                         asm volatile ("pshufb %xmm10,%xmm12");
    1360             :                         asm volatile ("pshufb %xmm11,%xmm13");
    1361             :                         asm volatile ("pxor   %xmm12,%xmm3");
    1362             :                         asm volatile ("pxor   %xmm13,%xmm3");
    1363             : 
    1364             :                         asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][2][0][0]));
    1365             :                         asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][2][1][0]));
    1366             :                         asm volatile ("pshufb %xmm10,%xmm12");
    1367             :                         asm volatile ("pshufb %xmm11,%xmm13");
    1368             :                         asm volatile ("pxor   %xmm12,%xmm4");
    1369             :                         asm volatile ("pxor   %xmm13,%xmm4");
    1370             :                 }
    1371             : 
    1372             :                 /* first disk with all coefficients at 1 */
    1373             :                 asm volatile ("movdqa %0,%%xmm10" : : "m" (v[0][i]));
    1374             : 
    1375             :                 asm volatile ("pxor %xmm11,%xmm11");
    1376             :                 asm volatile ("pcmpgtb %xmm1,%xmm11");
    1377             :                 asm volatile ("paddb %xmm1,%xmm1");
    1378             :                 asm volatile ("pand %xmm14,%xmm11");
    1379             :                 asm volatile ("pxor %xmm11,%xmm1");
    1380             : 
    1381             :                 asm volatile ("pxor %xmm10,%xmm0");
    1382             :                 asm volatile ("pxor %xmm10,%xmm1");
    1383             :                 asm volatile ("pxor %xmm10,%xmm2");
    1384             :                 asm volatile ("pxor %xmm10,%xmm3");
    1385             :                 asm volatile ("pxor %xmm10,%xmm4");
    1386             : 
    1387             :                 asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
    1388             :                 asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
    1389             :                 asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
    1390             :                 asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
    1391             :                 asm volatile ("movntdq %%xmm4,%0" : "=m" (t[i]));
    1392             :         }
    1393             : 
    1394             :         raid_sse_end();
    1395             : }
    1396             : #endif
    1397             : 
    1398             : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX2)
    1399             : /*
    1400             :  * GEN5 (penta parity with Cauchy matrix) AVX2 implementation
    1401             :  *
    1402             :  * Note that it uses 16 registers, meaning that x64 is required.
    1403             :  */
    1404             : void raid_gen5_avx2ext(int nd, size_t size, void **vv)
    1405             : {
    1406             :         uint8_t **v = (uint8_t **)vv;
    1407             :         uint8_t *p;
    1408             :         uint8_t *q;
    1409             :         uint8_t *r;
    1410             :         uint8_t *s;
    1411             :         uint8_t *t;
    1412             :         int d, l;
    1413             :         size_t i;
    1414             : 
    1415             :         l = nd - 1;
    1416             :         p = v[nd];
    1417             :         q = v[nd + 1];
    1418             :         r = v[nd + 2];
    1419             :         s = v[nd + 3];
    1420             :         t = v[nd + 4];
    1421             : 
    1422             :         /* special case with only one data disk */
    1423             :         if (l == 0) {
    1424             :                 for (i = 0; i < 5; ++i)
    1425             :                         memcpy(v[1 + i], v[0], size);
    1426             :                 return;
    1427             :         }
    1428             : 
    1429             :         raid_avx_begin();
    1430             : 
    1431             :         /* generic case with at least two data disks */
    1432             :         asm volatile ("vpxor %ymm8,%ymm8,%ymm8");
    1433             :         asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfconst16.poly[0]));
    1434             :         asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
    1435             : 
    1436             :         for (i = 0; i < size; i += 32) {
    1437             :                 /* last disk without the by two multiplication */
    1438             :                 asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[l][i]));
    1439             : 
    1440             :                 asm volatile ("vmovdqa %ymm10,%ymm0");
    1441             :                 asm volatile ("vmovdqa %ymm10,%ymm1");
    1442             : 
    1443             :                 asm volatile ("vpsrlw  $4,%ymm10,%ymm11");
    1444             :                 asm volatile ("vpand   %ymm15,%ymm10,%ymm10");
    1445             :                 asm volatile ("vpand   %ymm15,%ymm11,%ymm11");
    1446             : 
    1447             :                 asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfgenpshufb[l][0][0][0]));
    1448             :                 asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][0][1][0]));
    1449             :                 asm volatile ("vpshufb %ymm10,%ymm2,%ymm2");
    1450             :                 asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
    1451             :                 asm volatile ("vpxor   %ymm13,%ymm2,%ymm2");
    1452             : 
    1453             :                 asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfgenpshufb[l][1][0][0]));
    1454             :                 asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][1][1][0]));
    1455             :                 asm volatile ("vpshufb %ymm10,%ymm3,%ymm3");
    1456             :                 asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
    1457             :                 asm volatile ("vpxor   %ymm13,%ymm3,%ymm3");
    1458             : 
    1459             :                 asm volatile ("vbroadcasti128 %0,%%ymm4" : : "m" (gfgenpshufb[l][2][0][0]));
    1460             :                 asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][2][1][0]));
    1461             :                 asm volatile ("vpshufb %ymm10,%ymm4,%ymm4");
    1462             :                 asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
    1463             :                 asm volatile ("vpxor   %ymm13,%ymm4,%ymm4");
    1464             : 
    1465             :                 /* intermediate disks */
    1466             :                 for (d = l - 1; d > 0; --d) {
    1467             :                         asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[d][i]));
    1468             : 
    1469             :                         asm volatile ("vpcmpgtb %ymm1,%ymm8,%ymm11");
    1470             :                         asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
    1471             :                         asm volatile ("vpand %ymm14,%ymm11,%ymm11");
    1472             :                         asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
    1473             : 
    1474             :                         asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
    1475             :                         asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
    1476             : 
    1477             :                         asm volatile ("vpsrlw  $4,%ymm10,%ymm11");
    1478             :                         asm volatile ("vpand   %ymm15,%ymm10,%ymm10");
    1479             :                         asm volatile ("vpand   %ymm15,%ymm11,%ymm11");
    1480             : 
    1481             :                         asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][0][0][0]));
    1482             :                         asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][0][1][0]));
    1483             :                         asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
    1484             :                         asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
    1485             :                         asm volatile ("vpxor   %ymm12,%ymm2,%ymm2");
    1486             :                         asm volatile ("vpxor   %ymm13,%ymm2,%ymm2");
    1487             : 
    1488             :                         asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][1][0][0]));
    1489             :                         asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][1][1][0]));
    1490             :                         asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
    1491             :                         asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
    1492             :                         asm volatile ("vpxor   %ymm12,%ymm3,%ymm3");
    1493             :                         asm volatile ("vpxor   %ymm13,%ymm3,%ymm3");
    1494             : 
    1495             :                         asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][2][0][0]));
    1496             :                         asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][2][1][0]));
    1497             :                         asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
    1498             :                         asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
    1499             :                         asm volatile ("vpxor   %ymm12,%ymm4,%ymm4");
    1500             :                         asm volatile ("vpxor   %ymm13,%ymm4,%ymm4");
    1501             :                 }
    1502             : 
    1503             :                 /* first disk with all coefficients at 1 */
    1504             :                 asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[0][i]));
    1505             : 
    1506             :                 asm volatile ("vpcmpgtb %ymm1,%ymm8,%ymm11");
    1507             :                 asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
    1508             :                 asm volatile ("vpand %ymm14,%ymm11,%ymm11");
    1509             :                 asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
    1510             : 
    1511             :                 asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
    1512             :                 asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
    1513             :                 asm volatile ("vpxor %ymm10,%ymm2,%ymm2");
    1514             :                 asm volatile ("vpxor %ymm10,%ymm3,%ymm3");
    1515             :                 asm volatile ("vpxor %ymm10,%ymm4,%ymm4");
    1516             : 
    1517             :                 asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
    1518             :                 asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
    1519             :                 asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
    1520             :                 asm volatile ("vmovntdq %%ymm3,%0" : "=m" (s[i]));
    1521             :                 asm volatile ("vmovntdq %%ymm4,%0" : "=m" (t[i]));
    1522             :         }
    1523             : 
    1524             :         raid_avx_end();
    1525             : }
    1526             : #endif
    1527             : 
    1528             : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
    1529             : /*
    1530             :  * GEN6 (hexa parity with Cauchy matrix) SSSE3 implementation
    1531             :  */
    1532      564177 : void raid_gen6_ssse3(int nd, size_t size, void **vv)
    1533             : {
    1534      564177 :         uint8_t **v = (uint8_t **)vv;
    1535             :         uint8_t *p;
    1536             :         uint8_t *q;
    1537             :         uint8_t *r;
    1538             :         uint8_t *s;
    1539             :         uint8_t *t;
    1540             :         uint8_t *u;
    1541             :         int d, l;
    1542             :         size_t i;
    1543             :         uint8_t buffer[2*16+16];
    1544      564177 :         uint8_t *pd = __align_ptr(buffer, 16);
    1545             : 
    1546      564177 :         l = nd - 1;
    1547      564177 :         p = v[nd];
    1548      564177 :         q = v[nd + 1];
    1549      564177 :         r = v[nd + 2];
    1550      564177 :         s = v[nd + 3];
    1551      564177 :         t = v[nd + 4];
    1552      564177 :         u = v[nd + 5];
    1553             : 
    1554             :         /* special case with only one data disk */
    1555      564177 :         if (l == 0) {
    1556           7 :                 for (i = 0; i < 6; ++i)
    1557           6 :                         memcpy(v[1 + i], v[0], size);
    1558      564178 :                 return;
    1559             :         }
    1560             : 
    1561             :         raid_sse_begin();
    1562             : 
    1563             :         /* generic case with at least two data disks */
    1564    36098080 :         for (i = 0; i < size; i += 16) {
    1565             :                 /* last disk without the by two multiplication */
    1566    35533904 :                 asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
    1567             : 
    1568    35533904 :                 asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[0]));
    1569    35533904 :                 asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[16]));
    1570             : 
    1571    35533904 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
    1572    35533904 :                 asm volatile ("movdqa %xmm4,%xmm5");
    1573    35533904 :                 asm volatile ("psrlw  $4,%xmm5");
    1574    35533904 :                 asm volatile ("pand   %xmm7,%xmm4");
    1575    35533904 :                 asm volatile ("pand   %xmm7,%xmm5");
    1576             : 
    1577    35533904 :                 asm volatile ("movdqa %0,%%xmm0" : : "m" (gfgenpshufb[l][0][0][0]));
    1578    35533904 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
    1579    35533904 :                 asm volatile ("pshufb %xmm4,%xmm0");
    1580    35533904 :                 asm volatile ("pshufb %xmm5,%xmm7");
    1581    35533904 :                 asm volatile ("pxor   %xmm7,%xmm0");
    1582             : 
    1583    35533904 :                 asm volatile ("movdqa %0,%%xmm1" : : "m" (gfgenpshufb[l][1][0][0]));
    1584    35533904 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
    1585    35533904 :                 asm volatile ("pshufb %xmm4,%xmm1");
    1586    35533904 :                 asm volatile ("pshufb %xmm5,%xmm7");
    1587    35533904 :                 asm volatile ("pxor   %xmm7,%xmm1");
    1588             : 
    1589    35533904 :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][2][0][0]));
    1590    35533904 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][2][1][0]));
    1591    35533904 :                 asm volatile ("pshufb %xmm4,%xmm2");
    1592    35533904 :                 asm volatile ("pshufb %xmm5,%xmm7");
    1593    35533904 :                 asm volatile ("pxor   %xmm7,%xmm2");
    1594             : 
    1595    35533904 :                 asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][3][0][0]));
    1596    35533904 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][3][1][0]));
    1597    35533904 :                 asm volatile ("pshufb %xmm4,%xmm3");
    1598    35533904 :                 asm volatile ("pshufb %xmm5,%xmm7");
    1599    35533904 :                 asm volatile ("pxor   %xmm7,%xmm3");
    1600             : 
    1601             :                 /* intermediate disks */
    1602   183674416 :                 for (d = l - 1; d > 0; --d) {
    1603   148140512 :                         asm volatile ("movdqa %0,%%xmm5" : : "m" (pd[0]));
    1604   148140512 :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[16]));
    1605   148140512 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
    1606             : 
    1607   148140512 :                         asm volatile ("pxor %xmm4,%xmm4");
    1608   148140512 :                         asm volatile ("pcmpgtb %xmm6,%xmm4");
    1609   148140512 :                         asm volatile ("paddb %xmm6,%xmm6");
    1610   148140512 :                         asm volatile ("pand %xmm7,%xmm4");
    1611   148140512 :                         asm volatile ("pxor %xmm4,%xmm6");
    1612             : 
    1613   148140512 :                         asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
    1614             : 
    1615   148140512 :                         asm volatile ("pxor %xmm4,%xmm5");
    1616   148140512 :                         asm volatile ("pxor %xmm4,%xmm6");
    1617   148140512 :                         asm volatile ("movdqa %%xmm5,%0" : "=m" (pd[0]));
    1618   148140512 :                         asm volatile ("movdqa %%xmm6,%0" : "=m" (pd[16]));
    1619             : 
    1620   148140512 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
    1621   148140512 :                         asm volatile ("movdqa %xmm4,%xmm5");
    1622   148140512 :                         asm volatile ("psrlw  $4,%xmm5");
    1623   148140512 :                         asm volatile ("pand   %xmm7,%xmm4");
    1624   148140512 :                         asm volatile ("pand   %xmm7,%xmm5");
    1625             : 
    1626   148140512 :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
    1627   148140512 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
    1628   148140512 :                         asm volatile ("pshufb %xmm4,%xmm6");
    1629   148140512 :                         asm volatile ("pshufb %xmm5,%xmm7");
    1630   148140512 :                         asm volatile ("pxor   %xmm6,%xmm0");
    1631   148140512 :                         asm volatile ("pxor   %xmm7,%xmm0");
    1632             : 
    1633   148140512 :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
    1634   148140512 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
    1635   148140512 :                         asm volatile ("pshufb %xmm4,%xmm6");
    1636   148140512 :                         asm volatile ("pshufb %xmm5,%xmm7");
    1637   148140512 :                         asm volatile ("pxor   %xmm6,%xmm1");
    1638   148140512 :                         asm volatile ("pxor   %xmm7,%xmm1");
    1639             : 
    1640   148140512 :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][2][0][0]));
    1641   148140512 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][2][1][0]));
    1642   148140512 :                         asm volatile ("pshufb %xmm4,%xmm6");
    1643   148140512 :                         asm volatile ("pshufb %xmm5,%xmm7");
    1644   148140512 :                         asm volatile ("pxor   %xmm6,%xmm2");
    1645   148140512 :                         asm volatile ("pxor   %xmm7,%xmm2");
    1646             : 
    1647   148140512 :                         asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][3][0][0]));
    1648   148140512 :                         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][3][1][0]));
    1649   148140512 :                         asm volatile ("pshufb %xmm4,%xmm6");
    1650   148140512 :                         asm volatile ("pshufb %xmm5,%xmm7");
    1651   148140512 :                         asm volatile ("pxor   %xmm6,%xmm3");
    1652   148140512 :                         asm volatile ("pxor   %xmm7,%xmm3");
    1653             :                 }
    1654             : 
    1655             :                 /* first disk with all coefficients at 1 */
    1656    35533904 :                 asm volatile ("movdqa %0,%%xmm5" : : "m" (pd[0]));
    1657    35533904 :                 asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[16]));
    1658    35533904 :                 asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
    1659             : 
    1660    35533904 :                 asm volatile ("pxor %xmm4,%xmm4");
    1661    35533904 :                 asm volatile ("pcmpgtb %xmm6,%xmm4");
    1662    35533904 :                 asm volatile ("paddb %xmm6,%xmm6");
    1663    35533904 :                 asm volatile ("pand %xmm7,%xmm4");
    1664    35533904 :                 asm volatile ("pxor %xmm4,%xmm6");
    1665             : 
    1666    35533904 :                 asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
    1667    35533904 :                 asm volatile ("pxor %xmm4,%xmm0");
    1668    35533904 :                 asm volatile ("pxor %xmm4,%xmm1");
    1669    35533904 :                 asm volatile ("pxor %xmm4,%xmm2");
    1670    35533904 :                 asm volatile ("pxor %xmm4,%xmm3");
    1671    35533904 :                 asm volatile ("pxor %xmm4,%xmm5");
    1672    35533904 :                 asm volatile ("pxor %xmm4,%xmm6");
    1673             : 
    1674    35533904 :                 asm volatile ("movntdq %%xmm5,%0" : "=m" (p[i]));
    1675    35533904 :                 asm volatile ("movntdq %%xmm6,%0" : "=m" (q[i]));
    1676    35533904 :                 asm volatile ("movntdq %%xmm0,%0" : "=m" (r[i]));
    1677    35533904 :                 asm volatile ("movntdq %%xmm1,%0" : "=m" (s[i]));
    1678    35533904 :                 asm volatile ("movntdq %%xmm2,%0" : "=m" (t[i]));
    1679    35533904 :                 asm volatile ("movntdq %%xmm3,%0" : "=m" (u[i]));
    1680             :         }
    1681             : 
    1682             :         raid_sse_end();
    1683             : }
    1684             : #endif
    1685             : 
    1686             : #if defined(CONFIG_X86_64) && defined(CONFIG_SSSE3)
    1687             : /*
    1688             :  * GEN6 (hexa parity with Cauchy matrix) SSSE3 implementation
    1689             :  *
    1690             :  * Note that it uses 16 registers, meaning that x64 is required.
    1691             :  */
    1692             : void raid_gen6_ssse3ext(int nd, size_t size, void **vv)
    1693             : {
    1694             :         uint8_t **v = (uint8_t **)vv;
    1695             :         uint8_t *p;
    1696             :         uint8_t *q;
    1697             :         uint8_t *r;
    1698             :         uint8_t *s;
    1699             :         uint8_t *t;
    1700             :         uint8_t *u;
    1701             :         int d, l;
    1702             :         size_t i;
    1703             : 
    1704             :         l = nd - 1;
    1705             :         p = v[nd];
    1706             :         q = v[nd + 1];
    1707             :         r = v[nd + 2];
    1708             :         s = v[nd + 3];
    1709             :         t = v[nd + 4];
    1710             :         u = v[nd + 5];
    1711             : 
    1712             :         /* special case with only one data disk */
    1713             :         if (l == 0) {
    1714             :                 for (i = 0; i < 6; ++i)
    1715             :                         memcpy(v[1 + i], v[0], size);
    1716             :                 return;
    1717             :         }
    1718             : 
    1719             :         raid_sse_begin();
    1720             : 
    1721             :         /* generic case with at least two data disks */
    1722             :         asm volatile ("movdqa %0,%%xmm14" : : "m" (gfconst16.poly[0]));
    1723             :         asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
    1724             : 
    1725             :         for (i = 0; i < size; i += 16) {
    1726             :                 /* last disk without the by two multiplication */
    1727             :                 asm volatile ("movdqa %0,%%xmm10" : : "m" (v[l][i]));
    1728             : 
    1729             :                 asm volatile ("movdqa %xmm10,%xmm0");
    1730             :                 asm volatile ("movdqa %xmm10,%xmm1");
    1731             : 
    1732             :                 asm volatile ("movdqa %xmm10,%xmm11");
    1733             :                 asm volatile ("psrlw  $4,%xmm11");
    1734             :                 asm volatile ("pand   %xmm15,%xmm10");
    1735             :                 asm volatile ("pand   %xmm15,%xmm11");
    1736             : 
    1737             :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
    1738             :                 asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][0][1][0]));
    1739             :                 asm volatile ("pshufb %xmm10,%xmm2");
    1740             :                 asm volatile ("pshufb %xmm11,%xmm13");
    1741             :                 asm volatile ("pxor   %xmm13,%xmm2");
    1742             : 
    1743             :                 asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
    1744             :                 asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][1][1][0]));
    1745             :                 asm volatile ("pshufb %xmm10,%xmm3");
    1746             :                 asm volatile ("pshufb %xmm11,%xmm13");
    1747             :                 asm volatile ("pxor   %xmm13,%xmm3");
    1748             : 
    1749             :                 asm volatile ("movdqa %0,%%xmm4" : : "m" (gfgenpshufb[l][2][0][0]));
    1750             :                 asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][2][1][0]));
    1751             :                 asm volatile ("pshufb %xmm10,%xmm4");
    1752             :                 asm volatile ("pshufb %xmm11,%xmm13");
    1753             :                 asm volatile ("pxor   %xmm13,%xmm4");
    1754             : 
    1755             :                 asm volatile ("movdqa %0,%%xmm5" : : "m" (gfgenpshufb[l][3][0][0]));
    1756             :                 asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][3][1][0]));
    1757             :                 asm volatile ("pshufb %xmm10,%xmm5");
    1758             :                 asm volatile ("pshufb %xmm11,%xmm13");
    1759             :                 asm volatile ("pxor   %xmm13,%xmm5");
    1760             : 
    1761             :                 /* intermediate disks */
    1762             :                 for (d = l - 1; d > 0; --d) {
    1763             :                         asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i]));
    1764             : 
    1765             :                         asm volatile ("pxor %xmm11,%xmm11");
    1766             :                         asm volatile ("pcmpgtb %xmm1,%xmm11");
    1767             :                         asm volatile ("paddb %xmm1,%xmm1");
    1768             :                         asm volatile ("pand %xmm14,%xmm11");
    1769             :                         asm volatile ("pxor %xmm11,%xmm1");
    1770             : 
    1771             :                         asm volatile ("pxor %xmm10,%xmm0");
    1772             :                         asm volatile ("pxor %xmm10,%xmm1");
    1773             : 
    1774             :                         asm volatile ("movdqa %xmm10,%xmm11");
    1775             :                         asm volatile ("psrlw  $4,%xmm11");
    1776             :                         asm volatile ("pand   %xmm15,%xmm10");
    1777             :                         asm volatile ("pand   %xmm15,%xmm11");
    1778             : 
    1779             :                         asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][0][0][0]));
    1780             :                         asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][0][1][0]));
    1781             :                         asm volatile ("pshufb %xmm10,%xmm12");
    1782             :                         asm volatile ("pshufb %xmm11,%xmm13");
    1783             :                         asm volatile ("pxor   %xmm12,%xmm2");
    1784             :                         asm volatile ("pxor   %xmm13,%xmm2");
    1785             : 
    1786             :                         asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][1][0][0]));
    1787             :                         asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][1][1][0]));
    1788             :                         asm volatile ("pshufb %xmm10,%xmm12");
    1789             :                         asm volatile ("pshufb %xmm11,%xmm13");
    1790             :                         asm volatile ("pxor   %xmm12,%xmm3");
    1791             :                         asm volatile ("pxor   %xmm13,%xmm3");
    1792             : 
    1793             :                         asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][2][0][0]));
    1794             :                         asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][2][1][0]));
    1795             :                         asm volatile ("pshufb %xmm10,%xmm12");
    1796             :                         asm volatile ("pshufb %xmm11,%xmm13");
    1797             :                         asm volatile ("pxor   %xmm12,%xmm4");
    1798             :                         asm volatile ("pxor   %xmm13,%xmm4");
    1799             : 
    1800             :                         asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][3][0][0]));
    1801             :                         asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][3][1][0]));
    1802             :                         asm volatile ("pshufb %xmm10,%xmm12");
    1803             :                         asm volatile ("pshufb %xmm11,%xmm13");
    1804             :                         asm volatile ("pxor   %xmm12,%xmm5");
    1805             :                         asm volatile ("pxor   %xmm13,%xmm5");
    1806             :                 }
    1807             : 
    1808             :                 /* first disk with all coefficients at 1 */
    1809             :                 asm volatile ("movdqa %0,%%xmm10" : : "m" (v[0][i]));
    1810             : 
    1811             :                 asm volatile ("pxor %xmm11,%xmm11");
    1812             :                 asm volatile ("pcmpgtb %xmm1,%xmm11");
    1813             :                 asm volatile ("paddb %xmm1,%xmm1");
    1814             :                 asm volatile ("pand %xmm14,%xmm11");
    1815             :                 asm volatile ("pxor %xmm11,%xmm1");
    1816             : 
    1817             :                 asm volatile ("pxor %xmm10,%xmm0");
    1818             :                 asm volatile ("pxor %xmm10,%xmm1");
    1819             :                 asm volatile ("pxor %xmm10,%xmm2");
    1820             :                 asm volatile ("pxor %xmm10,%xmm3");
    1821             :                 asm volatile ("pxor %xmm10,%xmm4");
    1822             :                 asm volatile ("pxor %xmm10,%xmm5");
    1823             : 
    1824             :                 asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
    1825             :                 asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
    1826             :                 asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
    1827             :                 asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
    1828             :                 asm volatile ("movntdq %%xmm4,%0" : "=m" (t[i]));
    1829             :                 asm volatile ("movntdq %%xmm5,%0" : "=m" (u[i]));
    1830             :         }
    1831             : 
    1832             :         raid_sse_end();
    1833             : }
    1834             : #endif
    1835             : 
    1836             : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX2)
    1837             : /*
    1838             :  * GEN6 (hexa parity with Cauchy matrix) AVX2 implementation
    1839             :  *
    1840             :  * Note that it uses 16 registers, meaning that x64 is required.
    1841             :  */
    1842             : void raid_gen6_avx2ext(int nd, size_t size, void **vv)
    1843             : {
    1844             :         uint8_t **v = (uint8_t **)vv;
    1845             :         uint8_t *p;
    1846             :         uint8_t *q;
    1847             :         uint8_t *r;
    1848             :         uint8_t *s;
    1849             :         uint8_t *t;
    1850             :         uint8_t *u;
    1851             :         int d, l;
    1852             :         size_t i;
    1853             : 
    1854             :         l = nd - 1;
    1855             :         p = v[nd];
    1856             :         q = v[nd + 1];
    1857             :         r = v[nd + 2];
    1858             :         s = v[nd + 3];
    1859             :         t = v[nd + 4];
    1860             :         u = v[nd + 5];
    1861             : 
    1862             :         /* special case with only one data disk */
    1863             :         if (l == 0) {
    1864             :                 for (i = 0; i < 6; ++i)
    1865             :                         memcpy(v[1 + i], v[0], size);
    1866             :                 return;
    1867             :         }
    1868             : 
    1869             :         raid_avx_begin();
    1870             : 
    1871             :         /* generic case with at least two data disks */
    1872             :         asm volatile ("vpxor %ymm8,%ymm8,%ymm8");
    1873             :         asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfconst16.poly[0]));
    1874             :         asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
    1875             : 
    1876             :         for (i = 0; i < size; i += 32) {
    1877             :                 /* last disk without the by two multiplication */
    1878             :                 asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[l][i]));
    1879             : 
    1880             :                 asm volatile ("vmovdqa %ymm10,%ymm0");
    1881             :                 asm volatile ("vmovdqa %ymm10,%ymm1");
    1882             : 
    1883             :                 asm volatile ("vpsrlw  $4,%ymm10,%ymm11");
    1884             :                 asm volatile ("vpand   %ymm15,%ymm10,%ymm10");
    1885             :                 asm volatile ("vpand   %ymm15,%ymm11,%ymm11");
    1886             : 
    1887             :                 asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfgenpshufb[l][0][0][0]));
    1888             :                 asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][0][1][0]));
    1889             :                 asm volatile ("vpshufb %ymm10,%ymm2,%ymm2");
    1890             :                 asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
    1891             :                 asm volatile ("vpxor   %ymm13,%ymm2,%ymm2");
    1892             : 
    1893             :                 asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfgenpshufb[l][1][0][0]));
    1894             :                 asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][1][1][0]));
    1895             :                 asm volatile ("vpshufb %ymm10,%ymm3,%ymm3");
    1896             :                 asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
    1897             :                 asm volatile ("vpxor   %ymm13,%ymm3,%ymm3");
    1898             : 
    1899             :                 asm volatile ("vbroadcasti128 %0,%%ymm4" : : "m" (gfgenpshufb[l][2][0][0]));
    1900             :                 asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][2][1][0]));
    1901             :                 asm volatile ("vpshufb %ymm10,%ymm4,%ymm4");
    1902             :                 asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
    1903             :                 asm volatile ("vpxor   %ymm13,%ymm4,%ymm4");
    1904             : 
    1905             :                 asm volatile ("vbroadcasti128 %0,%%ymm5" : : "m" (gfgenpshufb[l][3][0][0]));
    1906             :                 asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][3][1][0]));
    1907             :                 asm volatile ("vpshufb %ymm10,%ymm5,%ymm5");
    1908             :                 asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
    1909             :                 asm volatile ("vpxor   %ymm13,%ymm5,%ymm5");
    1910             : 
    1911             :                 /* intermediate disks */
    1912             :                 for (d = l - 1; d > 0; --d) {
    1913             :                         asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[d][i]));
    1914             : 
    1915             :                         asm volatile ("vpcmpgtb %ymm1,%ymm8,%ymm11");
    1916             :                         asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
    1917             :                         asm volatile ("vpand %ymm14,%ymm11,%ymm11");
    1918             :                         asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
    1919             : 
    1920             :                         asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
    1921             :                         asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
    1922             : 
    1923             :                         asm volatile ("vpsrlw  $4,%ymm10,%ymm11");
    1924             :                         asm volatile ("vpand   %ymm15,%ymm10,%ymm10");
    1925             :                         asm volatile ("vpand   %ymm15,%ymm11,%ymm11");
    1926             : 
    1927             :                         asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][0][0][0]));
    1928             :                         asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][0][1][0]));
    1929             :                         asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
    1930             :                         asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
    1931             :                         asm volatile ("vpxor   %ymm12,%ymm2,%ymm2");
    1932             :                         asm volatile ("vpxor   %ymm13,%ymm2,%ymm2");
    1933             : 
    1934             :                         asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][1][0][0]));
    1935             :                         asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][1][1][0]));
    1936             :                         asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
    1937             :                         asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
    1938             :                         asm volatile ("vpxor   %ymm12,%ymm3,%ymm3");
    1939             :                         asm volatile ("vpxor   %ymm13,%ymm3,%ymm3");
    1940             : 
    1941             :                         asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][2][0][0]));
    1942             :                         asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][2][1][0]));
    1943             :                         asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
    1944             :                         asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
    1945             :                         asm volatile ("vpxor   %ymm12,%ymm4,%ymm4");
    1946             :                         asm volatile ("vpxor   %ymm13,%ymm4,%ymm4");
    1947             : 
    1948             :                         asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][3][0][0]));
    1949             :                         asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][3][1][0]));
    1950             :                         asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
    1951             :                         asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
    1952             :                         asm volatile ("vpxor   %ymm12,%ymm5,%ymm5");
    1953             :                         asm volatile ("vpxor   %ymm13,%ymm5,%ymm5");
    1954             :                 }
    1955             : 
    1956             :                 /* first disk with all coefficients at 1 */
    1957             :                 asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[0][i]));
    1958             : 
    1959             :                 asm volatile ("vpcmpgtb %ymm1,%ymm8,%ymm11");
    1960             :                 asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
    1961             :                 asm volatile ("vpand %ymm14,%ymm11,%ymm11");
    1962             :                 asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
    1963             : 
    1964             :                 asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
    1965             :                 asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
    1966             :                 asm volatile ("vpxor %ymm10,%ymm2,%ymm2");
    1967             :                 asm volatile ("vpxor %ymm10,%ymm3,%ymm3");
    1968             :                 asm volatile ("vpxor %ymm10,%ymm4,%ymm4");
    1969             :                 asm volatile ("vpxor %ymm10,%ymm5,%ymm5");
    1970             : 
    1971             :                 asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
    1972             :                 asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
    1973             :                 asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
    1974             :                 asm volatile ("vmovntdq %%ymm3,%0" : "=m" (s[i]));
    1975             :                 asm volatile ("vmovntdq %%ymm4,%0" : "=m" (t[i]));
    1976             :                 asm volatile ("vmovntdq %%ymm5,%0" : "=m" (u[i]));
    1977             :         }
    1978             : 
    1979             :         raid_avx_end();
    1980             : }
    1981             : #endif
    1982             : 
    1983             : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
    1984             : /*
    1985             :  * RAID recovering for one disk SSSE3 implementation
    1986             :  */
    1987      111395 : void raid_rec1_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
    1988             : {
    1989      111395 :         uint8_t **v = (uint8_t **)vv;
    1990             :         uint8_t *p;
    1991             :         uint8_t *pa;
    1992             :         uint8_t G;
    1993             :         uint8_t V;
    1994             :         size_t i;
    1995             : 
    1996             :         (void)nr; /* unused, it's always 1 */
    1997             : 
    1998             :         /* if it's RAID5 uses the faster function */
    1999      111395 :         if (ip[0] == 0) {
    2000      101506 :                 raid_rec1of1(id, nd, size, vv);
    2001      212901 :                 return;
    2002             :         }
    2003             : 
    2004             :         /* setup the coefficients matrix */
    2005       19778 :         G = A(ip[0], id[0]);
    2006             : 
    2007             :         /* invert it to solve the system of linear equations */
    2008       19778 :         V = inv(G);
    2009             : 
    2010             :         /* compute delta parity */
    2011        9889 :         raid_delta_gen(1, id, ip, nd, size, vv);
    2012             : 
    2013        9889 :         p = v[nd + ip[0]];
    2014        9889 :         pa = v[id[0]];
    2015             : 
    2016             :         raid_sse_begin();
    2017             : 
    2018        9889 :         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
    2019        9889 :         asm volatile ("movdqa %0,%%xmm4" : : "m" (gfmulpshufb[V][0][0]));
    2020        9889 :         asm volatile ("movdqa %0,%%xmm5" : : "m" (gfmulpshufb[V][1][0]));
    2021             : 
    2022     1552673 :         for (i = 0; i < size; i += 16) {
    2023     1542784 :                 asm volatile ("movdqa %0,%%xmm0" : : "m" (p[i]));
    2024     1542784 :                 asm volatile ("movdqa %0,%%xmm1" : : "m" (pa[i]));
    2025     1542784 :                 asm volatile ("movdqa %xmm4,%xmm2");
    2026     1542784 :                 asm volatile ("movdqa %xmm5,%xmm3");
    2027     1542784 :                 asm volatile ("pxor   %xmm0,%xmm1");
    2028     1542784 :                 asm volatile ("movdqa %xmm1,%xmm0");
    2029     1542784 :                 asm volatile ("psrlw  $4,%xmm1");
    2030     1542784 :                 asm volatile ("pand   %xmm7,%xmm0");
    2031     1542784 :                 asm volatile ("pand   %xmm7,%xmm1");
    2032     1542784 :                 asm volatile ("pshufb %xmm0,%xmm2");
    2033     1542784 :                 asm volatile ("pshufb %xmm1,%xmm3");
    2034     1542784 :                 asm volatile ("pxor   %xmm3,%xmm2");
    2035     1542784 :                 asm volatile ("movdqa %%xmm2,%0" : "=m" (pa[i]));
    2036             :         }
    2037             : 
    2038             :         raid_sse_end();
    2039             : }
    2040             : #endif
    2041             : 
    2042             : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
    2043             : /*
    2044             :  * RAID recovering for two disks SSSE3 implementation
    2045             :  */
    2046       44038 : void raid_rec2_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
    2047             : {
    2048       44038 :         uint8_t **v = (uint8_t **)vv;
    2049       44038 :         const int N = 2;
    2050       44038 :         uint8_t *p[N];
    2051       44038 :         uint8_t *pa[N];
    2052       44038 :         uint8_t G[N * N];
    2053       44038 :         uint8_t V[N * N];
    2054             :         size_t i;
    2055             :         int j, k;
    2056             : 
    2057             :         (void)nr; /* unused, it's always 2 */
    2058             : 
    2059             :         /* setup the coefficients matrix */
    2060      132114 :         for (j = 0; j < N; ++j)
    2061      264228 :                 for (k = 0; k < N; ++k)
    2062      352304 :                         G[j * N + k] = A(ip[j], id[k]);
    2063             : 
    2064             :         /* invert it to solve the system of linear equations */
    2065       44038 :         raid_invert(G, V, N);
    2066             : 
    2067             :         /* compute delta parity */
    2068       44038 :         raid_delta_gen(N, id, ip, nd, size, vv);
    2069             : 
    2070      132114 :         for (j = 0; j < N; ++j) {
    2071       88076 :                 p[j] = v[nd + ip[j]];
    2072       88076 :                 pa[j] = v[id[j]];
    2073             :         }
    2074             : 
    2075             :         raid_sse_begin();
    2076             : 
    2077       44038 :         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
    2078             : 
    2079     3588806 :         for (i = 0; i < size; i += 16) {
    2080     3544768 :                 asm volatile ("movdqa %0,%%xmm0" : : "m" (p[0][i]));
    2081     3544768 :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (pa[0][i]));
    2082     3544768 :                 asm volatile ("movdqa %0,%%xmm1" : : "m" (p[1][i]));
    2083     3544768 :                 asm volatile ("movdqa %0,%%xmm3" : : "m" (pa[1][i]));
    2084     3544768 :                 asm volatile ("pxor   %xmm2,%xmm0");
    2085     3544768 :                 asm volatile ("pxor   %xmm3,%xmm1");
    2086             : 
    2087     3544768 :                 asm volatile ("pxor %xmm6,%xmm6");
    2088             : 
    2089     3544768 :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[0]][0][0]));
    2090     3544768 :                 asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[0]][1][0]));
    2091     3544768 :                 asm volatile ("movdqa %xmm0,%xmm4");
    2092     3544768 :                 asm volatile ("movdqa %xmm0,%xmm5");
    2093     3544768 :                 asm volatile ("psrlw  $4,%xmm5");
    2094     3544768 :                 asm volatile ("pand   %xmm7,%xmm4");
    2095     3544768 :                 asm volatile ("pand   %xmm7,%xmm5");
    2096     3544768 :                 asm volatile ("pshufb %xmm4,%xmm2");
    2097     3544768 :                 asm volatile ("pshufb %xmm5,%xmm3");
    2098     3544768 :                 asm volatile ("pxor   %xmm2,%xmm6");
    2099     3544768 :                 asm volatile ("pxor   %xmm3,%xmm6");
    2100             : 
    2101     3544768 :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[1]][0][0]));
    2102     3544768 :                 asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[1]][1][0]));
    2103     3544768 :                 asm volatile ("movdqa %xmm1,%xmm4");
    2104     3544768 :                 asm volatile ("movdqa %xmm1,%xmm5");
    2105     3544768 :                 asm volatile ("psrlw  $4,%xmm5");
    2106     3544768 :                 asm volatile ("pand   %xmm7,%xmm4");
    2107     3544768 :                 asm volatile ("pand   %xmm7,%xmm5");
    2108     3544768 :                 asm volatile ("pshufb %xmm4,%xmm2");
    2109     3544768 :                 asm volatile ("pshufb %xmm5,%xmm3");
    2110     3544768 :                 asm volatile ("pxor   %xmm2,%xmm6");
    2111     3544768 :                 asm volatile ("pxor   %xmm3,%xmm6");
    2112             : 
    2113     3544768 :                 asm volatile ("movdqa %%xmm6,%0" : "=m" (pa[0][i]));
    2114             : 
    2115     3544768 :                 asm volatile ("pxor %xmm6,%xmm6");
    2116             : 
    2117     3544768 :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[2]][0][0]));
    2118     3544768 :                 asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[2]][1][0]));
    2119     3544768 :                 asm volatile ("movdqa %xmm0,%xmm4");
    2120     3544768 :                 asm volatile ("movdqa %xmm0,%xmm5");
    2121     3544768 :                 asm volatile ("psrlw  $4,%xmm5");
    2122     3544768 :                 asm volatile ("pand   %xmm7,%xmm4");
    2123     3544768 :                 asm volatile ("pand   %xmm7,%xmm5");
    2124     3544768 :                 asm volatile ("pshufb %xmm4,%xmm2");
    2125     3544768 :                 asm volatile ("pshufb %xmm5,%xmm3");
    2126     3544768 :                 asm volatile ("pxor   %xmm2,%xmm6");
    2127     3544768 :                 asm volatile ("pxor   %xmm3,%xmm6");
    2128             : 
    2129     3544768 :                 asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[3]][0][0]));
    2130     3544768 :                 asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[3]][1][0]));
    2131     3544768 :                 asm volatile ("movdqa %xmm1,%xmm4");
    2132     3544768 :                 asm volatile ("movdqa %xmm1,%xmm5");
    2133     3544768 :                 asm volatile ("psrlw  $4,%xmm5");
    2134     3544768 :                 asm volatile ("pand   %xmm7,%xmm4");
    2135     3544768 :                 asm volatile ("pand   %xmm7,%xmm5");
    2136     3544768 :                 asm volatile ("pshufb %xmm4,%xmm2");
    2137     3544768 :                 asm volatile ("pshufb %xmm5,%xmm3");
    2138     3544768 :                 asm volatile ("pxor   %xmm2,%xmm6");
    2139     3544768 :                 asm volatile ("pxor   %xmm3,%xmm6");
    2140             : 
    2141     3544768 :                 asm volatile ("movdqa %%xmm6,%0" : "=m" (pa[1][i]));
    2142             :         }
    2143             : 
    2144             :         raid_sse_end();
    2145       44038 : }
    2146             : #endif
    2147             : 
    2148             : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
    2149             : /*
    2150             :  * RAID recovering SSSE3 implementation
    2151             :  */
    2152       79288 : void raid_recX_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
    2153             : {
    2154       79288 :         uint8_t **v = (uint8_t **)vv;
    2155       79288 :         int N = nr;
    2156             :         uint8_t *p[RAID_PARITY_MAX];
    2157             :         uint8_t *pa[RAID_PARITY_MAX];
    2158             :         uint8_t G[RAID_PARITY_MAX * RAID_PARITY_MAX];
    2159             :         uint8_t V[RAID_PARITY_MAX * RAID_PARITY_MAX];
    2160             :         uint8_t buffer[RAID_PARITY_MAX*16+16];
    2161       79288 :         uint8_t *pd = __align_ptr(buffer, 16);
    2162             :         size_t i;
    2163             :         int j, k;
    2164             : 
    2165             :         /* setup the coefficients matrix */
    2166      435102 :         for (j = 0; j < N; ++j)
    2167     2046374 :                 for (k = 0; k < N; ++k)
    2168     3381120 :                         G[j * N + k] = A(ip[j], id[k]);
    2169             : 
    2170             :         /* invert it to solve the system of linear equations */
    2171       79288 :         raid_invert(G, V, N);
    2172             : 
    2173             :         /* compute delta parity */
    2174       79288 :         raid_delta_gen(N, id, ip, nd, size, vv);
    2175             : 
    2176      435102 :         for (j = 0; j < N; ++j) {
    2177      355814 :                 p[j] = v[nd + ip[j]];
    2178      355814 :                 pa[j] = v[id[j]];
    2179             :         }
    2180             : 
    2181             :         raid_sse_begin();
    2182             : 
    2183       79288 :         asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
    2184             : 
    2185     5869832 :         for (i = 0; i < size; i += 16) {
    2186             :                 /* delta */
    2187    32115408 :                 for (j = 0; j < N; ++j) {
    2188    26324864 :                         asm volatile ("movdqa %0,%%xmm0" : : "m" (p[j][i]));
    2189    26324864 :                         asm volatile ("movdqa %0,%%xmm1" : : "m" (pa[j][i]));
    2190    26324864 :                         asm volatile ("pxor   %xmm1,%xmm0");
    2191    26324864 :                         asm volatile ("movdqa %%xmm0,%0" : "=m" (pd[j*16]));
    2192             :                 }
    2193             : 
    2194             :                 /* reconstruct */
    2195    32115408 :                 for (j = 0; j < N; ++j) {
    2196    26324864 :                         asm volatile ("pxor %xmm0,%xmm0");
    2197    26324864 :                         asm volatile ("pxor %xmm1,%xmm1");
    2198             : 
    2199   153207872 :                         for (k = 0; k < N; ++k) {
    2200   126883008 :                                 uint8_t m = V[j * N + k];
    2201             : 
    2202   126883008 :                                 asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[m][0][0]));
    2203   126883008 :                                 asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[m][1][0]));
    2204   126883008 :                                 asm volatile ("movdqa %0,%%xmm4" : : "m" (pd[k*16]));
    2205   126883008 :                                 asm volatile ("movdqa %xmm4,%xmm5");
    2206   126883008 :                                 asm volatile ("psrlw  $4,%xmm5");
    2207   126883008 :                                 asm volatile ("pand   %xmm7,%xmm4");
    2208   126883008 :                                 asm volatile ("pand   %xmm7,%xmm5");
    2209   126883008 :                                 asm volatile ("pshufb %xmm4,%xmm2");
    2210   126883008 :                                 asm volatile ("pshufb %xmm5,%xmm3");
    2211   126883008 :                                 asm volatile ("pxor   %xmm2,%xmm0");
    2212   126883008 :                                 asm volatile ("pxor   %xmm3,%xmm1");
    2213             :                         }
    2214             : 
    2215    26324864 :                         asm volatile ("pxor %xmm1,%xmm0");
    2216    26324864 :                         asm volatile ("movdqa %%xmm0,%0" : "=m" (pa[j][i]));
    2217             :                 }
    2218             :         }
    2219             : 
    2220             :         raid_sse_end();
    2221       79288 : }
    2222             : #endif
    2223             : 
    2224             : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
    2225             : /*
    2226             :  * RAID recovering for one disk AVX2 implementation
    2227             :  */
    2228         126 : void raid_rec1_avx2(int nr, int *id, int *ip, int nd, size_t size, void **vv)
    2229             : {
    2230         126 :         uint8_t **v = (uint8_t **)vv;
    2231             :         uint8_t *p;
    2232             :         uint8_t *pa;
    2233             :         uint8_t G;
    2234             :         uint8_t V;
    2235             :         size_t i;
    2236             : 
    2237             :         (void)nr; /* unused, it's always 1 */
    2238             : 
    2239             :         /* if it's RAID5 uses the faster function */
    2240         126 :         if (ip[0] == 0) {
    2241          30 :                 raid_rec1of1(id, nd, size, vv);
    2242         156 :                 return;
    2243             :         }
    2244             : 
    2245             :         /* setup the coefficients matrix */
    2246         192 :         G = A(ip[0], id[0]);
    2247             : 
    2248             :         /* invert it to solve the system of linear equations */
    2249         192 :         V = inv(G);
    2250             : 
    2251             :         /* compute delta parity */
    2252          96 :         raid_delta_gen(1, id, ip, nd, size, vv);
    2253             : 
    2254          96 :         p = v[nd + ip[0]];
    2255          96 :         pa = v[id[0]];
    2256             : 
    2257             :         raid_avx_begin();
    2258             : 
    2259          96 :         asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.low4[0]));
    2260          96 :         asm volatile ("vbroadcasti128 %0,%%ymm4" : : "m" (gfmulpshufb[V][0][0]));
    2261          96 :         asm volatile ("vbroadcasti128 %0,%%ymm5" : : "m" (gfmulpshufb[V][1][0]));
    2262             : 
    2263       66816 :         for (i = 0; i < size; i += 32) {
    2264       66720 :                 asm volatile ("vmovdqa %0,%%ymm0" : : "m" (p[i]));
    2265       66720 :                 asm volatile ("vmovdqa %0,%%ymm1" : : "m" (pa[i]));
    2266       66720 :                 asm volatile ("vpxor   %ymm1,%ymm0,%ymm0");
    2267       66720 :                 asm volatile ("vpsrlw  $4,%ymm0,%ymm1");
    2268       66720 :                 asm volatile ("vpand   %ymm7,%ymm0,%ymm0");
    2269       66720 :                 asm volatile ("vpand   %ymm7,%ymm1,%ymm1");
    2270       66720 :                 asm volatile ("vpshufb %ymm0,%ymm4,%ymm2");
    2271       66720 :                 asm volatile ("vpshufb %ymm1,%ymm5,%ymm3");
    2272       66720 :                 asm volatile ("vpxor   %ymm3,%ymm2,%ymm2");
    2273       66720 :                 asm volatile ("vmovdqa %%ymm2,%0" : "=m" (pa[i]));
    2274             :         }
    2275             : 
    2276             :         raid_avx_end();
    2277             : }
    2278             : #endif
    2279             : 
    2280             : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
    2281             : /*
    2282             :  * RAID recovering for two disks AVX2 implementation
    2283             :  */
    2284        1206 : void raid_rec2_avx2(int nr, int *id, int *ip, int nd, size_t size, void **vv)
    2285             : {
    2286        1206 :         uint8_t **v = (uint8_t **)vv;
    2287        1206 :         const int N = 2;
    2288        1206 :         uint8_t *p[N];
    2289        1206 :         uint8_t *pa[N];
    2290        1206 :         uint8_t G[N * N];
    2291        1206 :         uint8_t V[N * N];
    2292             :         size_t i;
    2293             :         int j, k;
    2294             : 
    2295             :         (void)nr; /* unused, it's always 2 */
    2296             : 
    2297             :         /* setup the coefficients matrix */
    2298        3618 :         for (j = 0; j < N; ++j)
    2299        7236 :                 for (k = 0; k < N; ++k)
    2300        9648 :                         G[j * N + k] = A(ip[j], id[k]);
    2301             : 
    2302             :         /* invert it to solve the system of linear equations */
    2303        1206 :         raid_invert(G, V, N);
    2304             : 
    2305             :         /* compute delta parity */
    2306        1206 :         raid_delta_gen(N, id, ip, nd, size, vv);
    2307             : 
    2308        3618 :         for (j = 0; j < N; ++j) {
    2309        2412 :                 p[j] = v[nd + ip[j]];
    2310        2412 :                 pa[j] = v[id[j]];
    2311             :         }
    2312             : 
    2313             :         raid_avx_begin();
    2314             : 
    2315        1206 :         asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.low4[0]));
    2316             : 
    2317       77526 :         for (i = 0; i < size; i += 32) {
    2318       76320 :                 asm volatile ("vmovdqa %0,%%ymm0" : : "m" (p[0][i]));
    2319       76320 :                 asm volatile ("vmovdqa %0,%%ymm2" : : "m" (pa[0][i]));
    2320       76320 :                 asm volatile ("vmovdqa %0,%%ymm1" : : "m" (p[1][i]));
    2321       76320 :                 asm volatile ("vmovdqa %0,%%ymm3" : : "m" (pa[1][i]));
    2322       76320 :                 asm volatile ("vpxor   %ymm2,%ymm0,%ymm0");
    2323       76320 :                 asm volatile ("vpxor   %ymm3,%ymm1,%ymm1");
    2324             : 
    2325       76320 :                 asm volatile ("vpxor %ymm6,%ymm6,%ymm6");
    2326             : 
    2327       76320 :                 asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[V[0]][0][0]));
    2328       76320 :                 asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[V[0]][1][0]));
    2329       76320 :                 asm volatile ("vpsrlw  $4,%ymm0,%ymm5");
    2330       76320 :                 asm volatile ("vpand   %ymm7,%ymm0,%ymm4");
    2331       76320 :                 asm volatile ("vpand   %ymm7,%ymm5,%ymm5");
    2332       76320 :                 asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
    2333       76320 :                 asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
    2334       76320 :                 asm volatile ("vpxor   %ymm2,%ymm6,%ymm6");
    2335       76320 :                 asm volatile ("vpxor   %ymm3,%ymm6,%ymm6");
    2336             : 
    2337       76320 :                 asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[V[1]][0][0]));
    2338       76320 :                 asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[V[1]][1][0]));
    2339       76320 :                 asm volatile ("vpsrlw  $4,%ymm1,%ymm5");
    2340       76320 :                 asm volatile ("vpand   %ymm7,%ymm1,%ymm4");
    2341       76320 :                 asm volatile ("vpand   %ymm7,%ymm5,%ymm5");
    2342       76320 :                 asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
    2343       76320 :                 asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
    2344       76320 :                 asm volatile ("vpxor   %ymm2,%ymm6,%ymm6");
    2345       76320 :                 asm volatile ("vpxor   %ymm3,%ymm6,%ymm6");
    2346             : 
    2347       76320 :                 asm volatile ("vmovdqa %%ymm6,%0" : "=m" (pa[0][i]));
    2348             : 
    2349       76320 :                 asm volatile ("vpxor %ymm6,%ymm6,%ymm6");
    2350             : 
    2351       76320 :                 asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[V[2]][0][0]));
    2352       76320 :                 asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[V[2]][1][0]));
    2353       76320 :                 asm volatile ("vpsrlw  $4,%ymm0,%ymm5");
    2354       76320 :                 asm volatile ("vpand   %ymm7,%ymm0,%ymm4");
    2355       76320 :                 asm volatile ("vpand   %ymm7,%ymm5,%ymm5");
    2356       76320 :                 asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
    2357       76320 :                 asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
    2358       76320 :                 asm volatile ("vpxor   %ymm2,%ymm6,%ymm6");
    2359       76320 :                 asm volatile ("vpxor   %ymm3,%ymm6,%ymm6");
    2360             : 
    2361       76320 :                 asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[V[3]][0][0]));
    2362       76320 :                 asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[V[3]][1][0]));
    2363       76320 :                 asm volatile ("vpsrlw  $4,%ymm1,%ymm5");
    2364       76320 :                 asm volatile ("vpand   %ymm7,%ymm1,%ymm4");
    2365       76320 :                 asm volatile ("vpand   %ymm7,%ymm5,%ymm5");
    2366       76320 :                 asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
    2367       76320 :                 asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
    2368       76320 :                 asm volatile ("vpxor   %ymm2,%ymm6,%ymm6");
    2369       76320 :                 asm volatile ("vpxor   %ymm3,%ymm6,%ymm6");
    2370             : 
    2371       76320 :                 asm volatile ("vmovdqa %%ymm6,%0" : "=m" (pa[1][i]));
    2372             :         }
    2373             : 
    2374             :         raid_avx_end();
    2375        1206 : }
    2376             : #endif
    2377             : 
    2378             : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
    2379             : /*
    2380             :  * RAID recovering AVX2 implementation
    2381             :  */
    2382       17765 : void raid_recX_avx2(int nr, int *id, int *ip, int nd, size_t size, void **vv)
    2383             : {
    2384       17765 :         uint8_t **v = (uint8_t **)vv;
    2385       17765 :         int N = nr;
    2386             :         uint8_t *p[RAID_PARITY_MAX];
    2387             :         uint8_t *pa[RAID_PARITY_MAX];
    2388             :         uint8_t G[RAID_PARITY_MAX * RAID_PARITY_MAX];
    2389             :         uint8_t V[RAID_PARITY_MAX * RAID_PARITY_MAX];
    2390             :         uint8_t buffer[RAID_PARITY_MAX*32+32];
    2391       17765 :         uint8_t *pd = __align_ptr(buffer, 32);
    2392             :         size_t i;
    2393             :         int j, k;
    2394             : 
    2395             :         /* setup the coefficients matrix */
    2396       90821 :         for (j = 0; j < N; ++j)
    2397      386396 :                 for (k = 0; k < N; ++k)
    2398      626680 :                         G[j * N + k] = A(ip[j], id[k]);
    2399             : 
    2400             :         /* invert it to solve the system of linear equations */
    2401       17765 :         raid_invert(G, V, N);
    2402             : 
    2403             :         /* compute delta parity */
    2404       17765 :         raid_delta_gen(N, id, ip, nd, size, vv);
    2405             : 
    2406       90821 :         for (j = 0; j < N; ++j) {
    2407       73056 :                 p[j] = v[nd + ip[j]];
    2408       73056 :                 pa[j] = v[id[j]];
    2409             :         }
    2410             : 
    2411             :         raid_avx_begin();
    2412             : 
    2413       17765 :         asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.low4[0]));
    2414             : 
    2415      423213 :         for (i = 0; i < size; i += 32) {
    2416             :                 /* delta */
    2417     2174152 :                 for (j = 0; j < N; ++j) {
    2418     1768704 :                         asm volatile ("vmovdqa %0,%%ymm0" : : "m" (p[j][i]));
    2419     1768704 :                         asm volatile ("vmovdqa %0,%%ymm1" : : "m" (pa[j][i]));
    2420     1768704 :                         asm volatile ("vpxor   %ymm1,%ymm0,%ymm0");
    2421     1768704 :                         asm volatile ("vmovdqa %%ymm0,%0" : "=m" (pd[j*32]));
    2422             :                 }
    2423             : 
    2424             :                 /* reconstruct */
    2425     2174152 :                 for (j = 0; j < N; ++j) {
    2426     1768704 :                         asm volatile ("vpxor %ymm0,%ymm0,%ymm0");
    2427     1768704 :                         asm volatile ("vpxor %ymm1,%ymm1,%ymm1");
    2428             : 
    2429     9930976 :                         for (k = 0; k < N; ++k) {
    2430     8162272 :                                 uint8_t m = V[j * N + k];
    2431             : 
    2432     8162272 :                                 asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[m][0][0]));
    2433     8162272 :                                 asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[m][1][0]));
    2434     8162272 :                                 asm volatile ("vmovdqa %0,%%ymm4" : : "m" (pd[k*32]));
    2435     8162272 :                                 asm volatile ("vpsrlw  $4,%ymm4,%ymm5");
    2436     8162272 :                                 asm volatile ("vpand   %ymm7,%ymm4,%ymm4");
    2437     8162272 :                                 asm volatile ("vpand   %ymm7,%ymm5,%ymm5");
    2438     8162272 :                                 asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
    2439     8162272 :                                 asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
    2440     8162272 :                                 asm volatile ("vpxor   %ymm2,%ymm0,%ymm0");
    2441     8162272 :                                 asm volatile ("vpxor   %ymm3,%ymm1,%ymm1");
    2442             :                         }
    2443             : 
    2444     1768704 :                         asm volatile ("vpxor %ymm1,%ymm0,%ymm0");
    2445     1768704 :                         asm volatile ("vmovdqa %%ymm0,%0" : "=m" (pa[j][i]));
    2446             :                 }
    2447             :         }
    2448             : 
    2449             :         raid_avx_end();
    2450       17765 : }
    2451             : #endif
    2452             : 

Generated by: LCOV version 1.10