1 ########################################################################
2 # Implement fast CRC-T10DIF computation with SSE and PCLMULQDQ instructions
3 #
4 # Copyright (c) 2013, Intel Corporation
5 #
6 # Authors:
7 # Erdinc Ozturk <erdinc.ozturk@intel.com>
8 # Vinodh Gopal <vinodh.gopal@intel.com>
9 # James Guilford <james.guilford@intel.com>
10 # Tim Chen <tim.c.chen@linux.intel.com>
11 #
12 # This software is available to you under a choice of one of two
13 # licenses. You may choose to be licensed under the terms of the GNU
14 # General Public License (GPL) Version 2, available from the file
15 # COPYING in the main directory of this source tree, or the
16 # OpenIB.org BSD license below:
17 #
18 # Redistribution and use in source and binary forms, with or without
19 # modification, are permitted provided that the following conditions are
20 # met:
21 #
22 # * Redistributions of source code must retain the above copyright
23 # notice, this list of conditions and the following disclaimer.
24 #
25 # * Redistributions in binary form must reproduce the above copyright
26 # notice, this list of conditions and the following disclaimer in the
27 # documentation and/or other materials provided with the
28 # distribution.
29 #
30 # * Neither the name of the Intel Corporation nor the names of its
31 # contributors may be used to endorse or promote products derived from
32 # this software without specific prior written permission.
33 #
34 #
35 # THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION ""AS IS"" AND ANY
36 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
38 # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL CORPORATION OR
39 # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
40 # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
41 # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
42 # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
43 # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
44 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
45 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
46 #
47 # Reference paper titled "Fast CRC Computation for Generic
48 # Polynomials Using PCLMULQDQ Instruction"
49 # URL: http://www.intel.com/content/dam/www/public/us/en/documents
50 # /white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf
51 #
52
53 #include <linux/linkage.h>
54
55 .text
56
57 #define init_crc %edi
58 #define buf %rsi
59 #define len %rdx
60
61 #define FOLD_CONSTS %xmm10
62 #define BSWAP_MASK %xmm11
63
64 # Fold reg1, reg2 into the next 32 data bytes, storing the result back into
65 # reg1, reg2.
66 .macro fold_32_bytes offset, reg1, reg2
67 movdqu \offset(buf), %xmm9
68 movdqu \offset+16(buf), %xmm12
69 pshufb BSWAP_MASK, %xmm9
70 pshufb BSWAP_MASK, %xmm12
71 movdqa \reg1, %xmm8
72 movdqa \reg2, %xmm13
73 pclmulqdq $0x00, FOLD_CONSTS, \reg1
74 pclmulqdq $0x11, FOLD_CONSTS, %xmm8
75 pclmulqdq $0x00, FOLD_CONSTS, \reg2
76 pclmulqdq $0x11, FOLD_CONSTS, %xmm13
77 pxor %xmm9 , \reg1
78 xorps %xmm8 , \reg1
79 pxor %xmm12, \reg2
80 xorps %xmm13, \reg2
81 .endm
82
83 # Fold src_reg into dst_reg.
84 .macro fold_16_bytes src_reg, dst_reg
85 movdqa \src_reg, %xmm8
86 pclmulqdq $0x11, FOLD_CONSTS, \src_reg
87 pclmulqdq $0x00, FOLD_CONSTS, %xmm8
88 pxor %xmm8, \dst_reg
89 xorps \src_reg, \dst_reg
90 .endm
91
92 #
93 # u16 crc_t10dif_pcl(u16 init_crc, const *u8 buf, size_t len);
94 #
95 # Assumes len >= 16.
96 #
97 .align 16
98 ENTRY(crc_t10dif_pcl)
99
100 movdqa .Lbswap_mask(%rip), BSWAP_MASK
101
102 # For sizes less than 256 bytes, we can't fold 128 bytes at a time.
103 cmp $256, len
104 jl .Lless_than_256_bytes
105
106 # Load the first 128 data bytes. Byte swapping is necessary to make the
107 # bit order match the polynomial coefficient order.
108 movdqu 16*0(buf), %xmm0
109 movdqu 16*1(buf), %xmm1
110 movdqu 16*2(buf), %xmm2
111 movdqu 16*3(buf), %xmm3
112 movdqu 16*4(buf), %xmm4
113 movdqu 16*5(buf), %xmm5
114 movdqu 16*6(buf), %xmm6
115 movdqu 16*7(buf), %xmm7
116 add $128, buf
117 pshufb BSWAP_MASK, %xmm0
118 pshufb BSWAP_MASK, %xmm1
119 pshufb BSWAP_MASK, %xmm2
120 pshufb BSWAP_MASK, %xmm3
121 pshufb BSWAP_MASK, %xmm4
122 pshufb BSWAP_MASK, %xmm5
123 pshufb BSWAP_MASK, %xmm6
124 pshufb BSWAP_MASK, %xmm7
125
126 # XOR the first 16 data *bits* with the initial CRC value.
127 pxor %xmm8, %xmm8
128 pinsrw $7, init_crc, %xmm8
129 pxor %xmm8, %xmm0
130
131 movdqa .Lfold_across_128_bytes_consts(%rip), FOLD_CONSTS
132
133 # Subtract 128 for the 128 data bytes just consumed. Subtract another
134 # 128 to simplify the termination condition of the following loop.
135 sub $256, len
136
137 # While >= 128 data bytes remain (not counting xmm0-7), fold the 128
138 # bytes xmm0-7 into them, storing the result back into xmm0-7.
139 .Lfold_128_bytes_loop:
140 fold_32_bytes 0, %xmm0, %xmm1
141 fold_32_bytes 32, %xmm2, %xmm3
142 fold_32_bytes 64, %xmm4, %xmm5
143 fold_32_bytes 96, %xmm6, %xmm7
144 add $128, buf
145 sub $128, len
146 jge .Lfold_128_bytes_loop
147
148 # Now fold the 112 bytes in xmm0-xmm6 into the 16 bytes in xmm7.
149
150 # Fold across 64 bytes.
151 movdqa .Lfold_across_64_bytes_consts(%rip), FOLD_CONSTS
152 fold_16_bytes %xmm0, %xmm4
153 fold_16_bytes %xmm1, %xmm5
154 fold_16_bytes %xmm2, %xmm6
155 fold_16_bytes %xmm3, %xmm7
156 # Fold across 32 bytes.
157 movdqa .Lfold_across_32_bytes_consts(%rip), FOLD_CONSTS
158 fold_16_bytes %xmm4, %xmm6
159 fold_16_bytes %xmm5, %xmm7
160 # Fold across 16 bytes.
161 movdqa .Lfold_across_16_bytes_consts(%rip), FOLD_CONSTS
162 fold_16_bytes %xmm6, %xmm7
163
164 # Add 128 to get the correct number of data bytes remaining in 0...127
165 # (not counting xmm7), following the previous extra subtraction by 128.
166 # Then subtract 16 to simplify the termination condition of the
167 # following loop.
168 add $128-16, len
169
170 # While >= 16 data bytes remain (not counting xmm7), fold the 16 bytes
171 # xmm7 into them, storing the result back into xmm7.
172 jl .Lfold_16_bytes_loop_done
173 .Lfold_16_bytes_loop:
174 movdqa %xmm7, %xmm8
175 pclmulqdq $0x11, FOLD_CONSTS, %xmm7
176 pclmulqdq $0x00, FOLD_CONSTS, %xmm8
177 pxor %xmm8, %xmm7
178 movdqu (buf), %xmm0
179 pshufb BSWAP_MASK, %xmm0
180 pxor %xmm0 , %xmm7
181 add $16, buf
182 sub $16, len
183 jge .Lfold_16_bytes_loop
184
185 .Lfold_16_bytes_loop_done:
186 # Add 16 to get the correct number of data bytes remaining in 0...15
187 # (not counting xmm7), following the previous extra subtraction by 16.
188 add $16, len
189 je .Lreduce_final_16_bytes
190
191 .Lhandle_partial_segment:
192 # Reduce the last '16 + len' bytes where 1 <= len <= 15 and the first 16
193 # bytes are in xmm7 and the rest are the remaining data in 'buf'. To do
194 # this without needing a fold constant for each possible 'len', redivide
195 # the bytes into a first chunk of 'len' bytes and a second chunk of 16
196 # bytes, then fold the first chunk into the second.
197
198 movdqa %xmm7, %xmm2
199
200 # xmm1 = last 16 original data bytes
201 movdqu -16(buf, len), %xmm1
202 pshufb BSWAP_MASK, %xmm1
203
204 # xmm2 = high order part of second chunk: xmm7 left-shifted by 'len' bytes.
205 lea .Lbyteshift_table+16(%rip), %rax
206 sub len, %rax
207 movdqu (%rax), %xmm0
208 pshufb %xmm0, %xmm2
209
210 # xmm7 = first chunk: xmm7 right-shifted by '16-len' bytes.
211 pxor .Lmask1(%rip), %xmm0
212 pshufb %xmm0, %xmm7
213
214 # xmm1 = second chunk: 'len' bytes from xmm1 (low-order bytes),
215 # then '16-len' bytes from xmm2 (high-order bytes).
216 pblendvb %xmm2, %xmm1 #xmm0 is implicit
217
218 # Fold the first chunk into the second chunk, storing the result in xmm7.
219 movdqa %xmm7, %xmm8
220 pclmulqdq $0x11, FOLD_CONSTS, %xmm7
221 pclmulqdq $0x00, FOLD_CONSTS, %xmm8
222 pxor %xmm8, %xmm7
223 pxor %xmm1, %xmm7
224
225 .Lreduce_final_16_bytes:
226 # Reduce the 128-bit value M(x), stored in xmm7, to the final 16-bit CRC
227
228 # Load 'x^48 * (x^48 mod G(x))' and 'x^48 * (x^80 mod G(x))'.
229 movdqa .Lfinal_fold_consts(%rip), FOLD_CONSTS
230
231 # Fold the high 64 bits into the low 64 bits, while also multiplying by
232 # x^64. This produces a 128-bit value congruent to x^64 * M(x) and
233 # whose low 48 bits are 0.
234 movdqa %xmm7, %xmm0
235 pclmulqdq $0x11, FOLD_CONSTS, %xmm7 # high bits * x^48 * (x^80 mod G(x))
236 pslldq $8, %xmm0
237 pxor %xmm0, %xmm7 # + low bits * x^64
238
239 # Fold the high 32 bits into the low 96 bits. This produces a 96-bit
240 # value congruent to x^64 * M(x) and whose low 48 bits are 0.
241 movdqa %xmm7, %xmm0
242 pand .Lmask2(%rip), %xmm0 # zero high 32 bits
243 psrldq $12, %xmm7 # extract high 32 bits
244 pclmulqdq $0x00, FOLD_CONSTS, %xmm7 # high 32 bits * x^48 * (x^48 mod G(x))
245 pxor %xmm0, %xmm7 # + low bits
246
247 # Load G(x) and floor(x^48 / G(x)).
248 movdqa .Lbarrett_reduction_consts(%rip), FOLD_CONSTS
249
250 # Use Barrett reduction to compute the final CRC value.
251 movdqa %xmm7, %xmm0
252 pclmulqdq $0x11, FOLD_CONSTS, %xmm7 # high 32 bits * floor(x^48 / G(x))
253 psrlq $32, %xmm7 # /= x^32
254 pclmulqdq $0x00, FOLD_CONSTS, %xmm7 # *= G(x)
255 psrlq $48, %xmm0
256 pxor %xmm7, %xmm0 # + low 16 nonzero bits
257 # Final CRC value (x^16 * M(x)) mod G(x) is in low 16 bits of xmm0.
258
259 pextrw $0, %xmm0, %eax
260 ret
261
262 .align 16
263 .Lless_than_256_bytes:
264 # Checksumming a buffer of length 16...255 bytes
265
266 # Load the first 16 data bytes.
267 movdqu (buf), %xmm7
268 pshufb BSWAP_MASK, %xmm7
269 add $16, buf
270
271 # XOR the first 16 data *bits* with the initial CRC value.
272 pxor %xmm0, %xmm0
273 pinsrw $7, init_crc, %xmm0
274 pxor %xmm0, %xmm7
275
276 movdqa .Lfold_across_16_bytes_consts(%rip), FOLD_CONSTS
277 cmp $16, len
278 je .Lreduce_final_16_bytes # len == 16
279 sub $32, len
280 jge .Lfold_16_bytes_loop # 32 <= len <= 255
281 add $16, len
282 jmp .Lhandle_partial_segment # 17 <= len <= 31
283 ENDPROC(crc_t10dif_pcl)
284
285 .section .rodata, "a", @progbits
286 .align 16
287
288 # Fold constants precomputed from the polynomial 0x18bb7
289 # G(x) = x^16 + x^15 + x^11 + x^9 + x^8 + x^7 + x^5 + x^4 + x^2 + x^1 + x^0
290 .Lfold_across_128_bytes_consts:
291 .quad 0x0000000000006123 # x^(8*128) mod G(x)
292 .quad 0x0000000000002295 # x^(8*128+64) mod G(x)
293 .Lfold_across_64_bytes_consts:
294 .quad 0x0000000000001069 # x^(4*128) mod G(x)
295 .quad 0x000000000000dd31 # x^(4*128+64) mod G(x)
296 .Lfold_across_32_bytes_consts:
297 .quad 0x000000000000857d # x^(2*128) mod G(x)
298 .quad 0x0000000000007acc # x^(2*128+64) mod G(x)
299 .Lfold_across_16_bytes_consts:
300 .quad 0x000000000000a010 # x^(1*128) mod G(x)
301 .quad 0x0000000000001faa # x^(1*128+64) mod G(x)
302 .Lfinal_fold_consts:
303 .quad 0x1368000000000000 # x^48 * (x^48 mod G(x))
304 .quad 0x2d56000000000000 # x^48 * (x^80 mod G(x))
305 .Lbarrett_reduction_consts:
306 .quad 0x0000000000018bb7 # G(x)
307 .quad 0x00000001f65a57f8 # floor(x^48 / G(x))
308
309 .section .rodata.cst16.mask1, "aM", @progbits, 16
310 .align 16
311 .Lmask1:
312 .octa 0x80808080808080808080808080808080
313
314 .section .rodata.cst16.mask2, "aM", @progbits, 16
315 .align 16
316 .Lmask2:
317 .octa 0x00000000FFFFFFFFFFFFFFFFFFFFFFFF
318
319 .section .rodata.cst16.bswap_mask, "aM", @progbits, 16
320 .align 16
321 .Lbswap_mask:
322 .octa 0x000102030405060708090A0B0C0D0E0F
323
324 .section .rodata.cst32.byteshift_table, "aM", @progbits, 32
325 .align 16
326 # For 1 <= len <= 15, the 16-byte vector beginning at &byteshift_table[16 - len]
327 # is the index vector to shift left by 'len' bytes, and is also {0x80, ...,
328 # 0x80} XOR the index vector to shift right by '16 - len' bytes.
329 .Lbyteshift_table:
330 .byte 0x0, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87
331 .byte 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f
332 .byte 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7
333 .byte 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe , 0x0