arch/arm/crypto/aes-ce-glue.c

175

while ((blocks = (walk.nbytes / AES_BLOCK_SIZE))) {

arch/arm/crypto/aes-ce-glue.c

180

err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE);

arch/arm/crypto/aes-ce-glue.c

195

while ((blocks = (walk.nbytes / AES_BLOCK_SIZE))) {

arch/arm/crypto/aes-ce-glue.c

200

err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE);

arch/arm/crypto/aes-ce-glue.c

213

while ((blocks = (walk->nbytes / AES_BLOCK_SIZE))) {

arch/arm/crypto/aes-ce-glue.c

219

err = skcipher_walk_done(walk, walk->nbytes % AES_BLOCK_SIZE);

arch/arm/crypto/aes-ce-glue.c

243

while ((blocks = (walk->nbytes / AES_BLOCK_SIZE))) {

arch/arm/crypto/aes-ce-glue.c

249

err = skcipher_walk_done(walk, walk->nbytes % AES_BLOCK_SIZE);

arch/arm/crypto/aes-ce-glue.c

269

int cbc_blocks = DIV_ROUND_UP(req->cryptlen, AES_BLOCK_SIZE) - 2;

arch/arm/crypto/aes-ce-glue.c

280

if (req->cryptlen <= AES_BLOCK_SIZE) {

arch/arm/crypto/aes-ce-glue.c

281

if (req->cryptlen < AES_BLOCK_SIZE)

arch/arm/crypto/aes-ce-glue.c

288

cbc_blocks * AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

296

if (req->cryptlen == AES_BLOCK_SIZE)

arch/arm/crypto/aes-ce-glue.c

307

req->cryptlen - cbc_blocks * AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

327

int cbc_blocks = DIV_ROUND_UP(req->cryptlen, AES_BLOCK_SIZE) - 2;

arch/arm/crypto/aes-ce-glue.c

338

if (req->cryptlen <= AES_BLOCK_SIZE) {

arch/arm/crypto/aes-ce-glue.c

339

if (req->cryptlen < AES_BLOCK_SIZE)

arch/arm/crypto/aes-ce-glue.c

346

cbc_blocks * AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

354

if (req->cryptlen == AES_BLOCK_SIZE)

arch/arm/crypto/aes-ce-glue.c

365

req->cryptlen - cbc_blocks * AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

390

while ((blocks = (walk.nbytes / AES_BLOCK_SIZE))) {

arch/arm/crypto/aes-ce-glue.c

396

err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE);

arch/arm/crypto/aes-ce-glue.c

399

u8 __aligned(8) tail[AES_BLOCK_SIZE];

arch/arm/crypto/aes-ce-glue.c

424

int tail = req->cryptlen % AES_BLOCK_SIZE;

arch/arm/crypto/aes-ce-glue.c

430

if (req->cryptlen < AES_BLOCK_SIZE)

arch/arm/crypto/aes-ce-glue.c

437

AES_BLOCK_SIZE) - 2;

arch/arm/crypto/aes-ce-glue.c

446

xts_blocks * AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

454

for (first = 1; walk.nbytes >= AES_BLOCK_SIZE; first = 0) {

arch/arm/crypto/aes-ce-glue.c

458

nbytes &= ~(AES_BLOCK_SIZE - 1);

arch/arm/crypto/aes-ce-glue.c

475

skcipher_request_set_crypt(req, src, dst, AES_BLOCK_SIZE + tail,

arch/arm/crypto/aes-ce-glue.c

496

int tail = req->cryptlen % AES_BLOCK_SIZE;

arch/arm/crypto/aes-ce-glue.c

502

if (req->cryptlen < AES_BLOCK_SIZE)

arch/arm/crypto/aes-ce-glue.c

509

AES_BLOCK_SIZE) - 2;

arch/arm/crypto/aes-ce-glue.c

518

xts_blocks * AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

52

u8 b[AES_BLOCK_SIZE];

arch/arm/crypto/aes-ce-glue.c

526

for (first = 1; walk.nbytes >= AES_BLOCK_SIZE; first = 0) {

arch/arm/crypto/aes-ce-glue.c

530

nbytes &= ~(AES_BLOCK_SIZE - 1);

arch/arm/crypto/aes-ce-glue.c

547

skcipher_request_set_crypt(req, src, dst, AES_BLOCK_SIZE + tail,

arch/arm/crypto/aes-ce-glue.c

567

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

580

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

586

.ivsize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

594

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

600

.ivsize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

601

.walksize = 2 * AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

615

.ivsize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

616

.chunksize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

624

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

630

.ivsize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-ce-glue.c

631

.walksize = 2 * AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

102

walk.nbytes - blocks * AES_BLOCK_SIZE);

arch/arm/crypto/aes-neonbs-glue.c

152

while ((nbytes = walk.nbytes) >= AES_BLOCK_SIZE) {

arch/arm/crypto/aes-neonbs-glue.c

158

crypto_xor_cpy(dst, src, prev, AES_BLOCK_SIZE);

arch/arm/crypto/aes-neonbs-glue.c

161

src += AES_BLOCK_SIZE;

arch/arm/crypto/aes-neonbs-glue.c

162

dst += AES_BLOCK_SIZE;

arch/arm/crypto/aes-neonbs-glue.c

163

nbytes -= AES_BLOCK_SIZE;

arch/arm/crypto/aes-neonbs-glue.c

164

} while (nbytes >= AES_BLOCK_SIZE);

arch/arm/crypto/aes-neonbs-glue.c

165

memcpy(walk.iv, prev, AES_BLOCK_SIZE);

arch/arm/crypto/aes-neonbs-glue.c

180

while (walk.nbytes >= AES_BLOCK_SIZE) {

arch/arm/crypto/aes-neonbs-glue.c

181

unsigned int blocks = walk.nbytes / AES_BLOCK_SIZE;

arch/arm/crypto/aes-neonbs-glue.c

185

walk.stride / AES_BLOCK_SIZE);

arch/arm/crypto/aes-neonbs-glue.c

193

walk.nbytes - blocks * AES_BLOCK_SIZE);

arch/arm/crypto/aes-neonbs-glue.c

204

u8 buf[AES_BLOCK_SIZE];

arch/arm/crypto/aes-neonbs-glue.c

214

if (unlikely(bytes < AES_BLOCK_SIZE))

arch/arm/crypto/aes-neonbs-glue.c

218

bytes &= ~(8 * AES_BLOCK_SIZE - 1);

arch/arm/crypto/aes-neonbs-glue.c

224

if (unlikely(bytes < AES_BLOCK_SIZE))

arch/arm/crypto/aes-neonbs-glue.c

262

int tail = req->cryptlen % AES_BLOCK_SIZE;

arch/arm/crypto/aes-neonbs-glue.c

264

u8 buf[2 * AES_BLOCK_SIZE];

arch/arm/crypto/aes-neonbs-glue.c

268

if (req->cryptlen < AES_BLOCK_SIZE)

arch/arm/crypto/aes-neonbs-glue.c

287

while (walk.nbytes >= AES_BLOCK_SIZE) {

arch/arm/crypto/aes-neonbs-glue.c

288

unsigned int blocks = walk.nbytes / AES_BLOCK_SIZE;

arch/arm/crypto/aes-neonbs-glue.c

293

walk.stride / AES_BLOCK_SIZE);

arch/arm/crypto/aes-neonbs-glue.c

302

walk.nbytes - blocks * AES_BLOCK_SIZE);

arch/arm/crypto/aes-neonbs-glue.c

309

scatterwalk_map_and_copy(buf, req->dst, req->cryptlen - AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

310

AES_BLOCK_SIZE, 0);

arch/arm/crypto/aes-neonbs-glue.c

311

memcpy(buf + AES_BLOCK_SIZE, buf, tail);

arch/arm/crypto/aes-neonbs-glue.c

314

crypto_xor(buf, req->iv, AES_BLOCK_SIZE);

arch/arm/crypto/aes-neonbs-glue.c

321

crypto_xor(buf, req->iv, AES_BLOCK_SIZE);

arch/arm/crypto/aes-neonbs-glue.c

323

scatterwalk_map_and_copy(buf, req->dst, req->cryptlen - AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

324

AES_BLOCK_SIZE + tail, 1);

arch/arm/crypto/aes-neonbs-glue.c

342

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

348

.walksize = 8 * AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

356

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

362

.walksize = 8 * AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

363

.ivsize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

377

.chunksize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

378

.walksize = 8 * AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

379

.ivsize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

387

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

393

.walksize = 8 * AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

394

.ivsize = AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

45

u8 rk[13 * (8 * AES_BLOCK_SIZE) + 32] __aligned(AES_BLOCK_SIZE);

arch/arm/crypto/aes-neonbs-glue.c

90

while (walk.nbytes >= AES_BLOCK_SIZE) {

arch/arm/crypto/aes-neonbs-glue.c

91

unsigned int blocks = walk.nbytes / AES_BLOCK_SIZE;

arch/arm/crypto/aes-neonbs-glue.c

95

walk.stride / AES_BLOCK_SIZE);

arch/arm/crypto/ghash-ce-glue.c

215

aes_encrypt(&aes_key, (u8 *)&k, (u8[AES_BLOCK_SIZE]){});

arch/arm/crypto/ghash-ce-glue.c

312

u8 buf[AES_BLOCK_SIZE];

arch/arm/crypto/ghash-ce-glue.c

330

while (walk.nbytes >= AES_BLOCK_SIZE) {

arch/arm/crypto/ghash-ce-glue.c

331

int nblocks = walk.nbytes / AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

338

src += nblocks * AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

339

dst += nblocks * AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

346

walk.nbytes % AES_BLOCK_SIZE);

arch/arm/crypto/ghash-ce-glue.c

361

tail = walk.nbytes % AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

400

u8 otag[AES_BLOCK_SIZE];

arch/arm/crypto/ghash-ce-glue.c

401

u8 buf[AES_BLOCK_SIZE];

arch/arm/crypto/ghash-ce-glue.c

423

while (walk.nbytes >= AES_BLOCK_SIZE) {

arch/arm/crypto/ghash-ce-glue.c

424

int nblocks = walk.nbytes / AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

431

src += nblocks * AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

432

dst += nblocks * AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

439

walk.nbytes % AES_BLOCK_SIZE);

arch/arm/crypto/ghash-ce-glue.c

453

tail = walk.nbytes % AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

532

.chunksize = AES_BLOCK_SIZE,

arch/arm/crypto/ghash-ce-glue.c

533

.maxauthsize = AES_BLOCK_SIZE,

arch/arm/crypto/ghash-ce-glue.c

547

.chunksize = AES_BLOCK_SIZE,

arch/arm/crypto/ghash-ce-glue.c

548

.maxauthsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-ce-ccm-glue.c

102

int enc_after = (macp + abytes) % AES_BLOCK_SIZE;

arch/arm64/crypto/aes-ce-ccm-glue.c

105

u32 blocks = abytes / AES_BLOCK_SIZE;

arch/arm64/crypto/aes-ce-ccm-glue.c

107

if (macp == AES_BLOCK_SIZE || (!macp && blocks > 0)) {

arch/arm64/crypto/aes-ce-ccm-glue.c

110

u32 adv = (blocks - rem) * AES_BLOCK_SIZE;

arch/arm64/crypto/aes-ce-ccm-glue.c

112

macp = enc_after ? 0 : AES_BLOCK_SIZE;

arch/arm64/crypto/aes-ce-ccm-glue.c

119

u32 l = min(AES_BLOCK_SIZE - macp, abytes);

arch/arm64/crypto/aes-ce-ccm-glue.c

138

u32 macp = AES_BLOCK_SIZE;

arch/arm64/crypto/aes-ce-ccm-glue.c

170

u8 __aligned(8) mac[AES_BLOCK_SIZE];

arch/arm64/crypto/aes-ce-ccm-glue.c

171

u8 orig_iv[AES_BLOCK_SIZE];

arch/arm64/crypto/aes-ce-ccm-glue.c

180

memcpy(orig_iv, req->iv, AES_BLOCK_SIZE);

arch/arm64/crypto/aes-ce-ccm-glue.c

191

u32 tail = walk.nbytes % AES_BLOCK_SIZE;

arch/arm64/crypto/aes-ce-ccm-glue.c

194

u8 buf[AES_BLOCK_SIZE];

arch/arm64/crypto/aes-ce-ccm-glue.c

202

if (unlikely(walk.nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/aes-ce-ccm-glue.c

210

if (unlikely(walk.nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/aes-ce-ccm-glue.c

235

u8 __aligned(8) mac[AES_BLOCK_SIZE];

arch/arm64/crypto/aes-ce-ccm-glue.c

236

u8 orig_iv[AES_BLOCK_SIZE];

arch/arm64/crypto/aes-ce-ccm-glue.c

245

memcpy(orig_iv, req->iv, AES_BLOCK_SIZE);

arch/arm64/crypto/aes-ce-ccm-glue.c

256

u32 tail = walk.nbytes % AES_BLOCK_SIZE;

arch/arm64/crypto/aes-ce-ccm-glue.c

259

u8 buf[AES_BLOCK_SIZE];

arch/arm64/crypto/aes-ce-ccm-glue.c

267

if (unlikely(walk.nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/aes-ce-ccm-glue.c

275

if (unlikely(walk.nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/aes-ce-ccm-glue.c

306

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-ce-ccm-glue.c

307

.chunksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-ce-ccm-glue.c

308

.maxauthsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-ce-ccm-glue.c

64

__be32 *n = (__be32 *)&maciv[AES_BLOCK_SIZE - 8];

arch/arm64/crypto/aes-ce-ccm-glue.c

82

memcpy(maciv, req->iv, AES_BLOCK_SIZE - l);

arch/arm64/crypto/aes-ce-ccm-glue.c

95

memset(&req->iv[AES_BLOCK_SIZE - l], 0, l);

arch/arm64/crypto/aes-glue.c

132

u8 dg[AES_BLOCK_SIZE];

arch/arm64/crypto/aes-glue.c

187

while ((blocks = (walk.nbytes / AES_BLOCK_SIZE))) {

arch/arm64/crypto/aes-glue.c

191

err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE);

arch/arm64/crypto/aes-glue.c

206

while ((blocks = (walk.nbytes / AES_BLOCK_SIZE))) {

arch/arm64/crypto/aes-glue.c

210

err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE);

arch/arm64/crypto/aes-glue.c

223

while ((blocks = (walk->nbytes / AES_BLOCK_SIZE))) {

arch/arm64/crypto/aes-glue.c

227

err = skcipher_walk_done(walk, walk->nbytes % AES_BLOCK_SIZE);

arch/arm64/crypto/aes-glue.c

251

while ((blocks = (walk->nbytes / AES_BLOCK_SIZE))) {

arch/arm64/crypto/aes-glue.c

255

err = skcipher_walk_done(walk, walk->nbytes % AES_BLOCK_SIZE);

arch/arm64/crypto/aes-glue.c

276

int cbc_blocks = DIV_ROUND_UP(req->cryptlen, AES_BLOCK_SIZE) - 2;

arch/arm64/crypto/aes-glue.c

286

if (req->cryptlen <= AES_BLOCK_SIZE) {

arch/arm64/crypto/aes-glue.c

287

if (req->cryptlen < AES_BLOCK_SIZE)

arch/arm64/crypto/aes-glue.c

294

cbc_blocks * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

302

if (req->cryptlen == AES_BLOCK_SIZE)

arch/arm64/crypto/aes-glue.c

313

req->cryptlen - cbc_blocks * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

332

int cbc_blocks = DIV_ROUND_UP(req->cryptlen, AES_BLOCK_SIZE) - 2;

arch/arm64/crypto/aes-glue.c

342

if (req->cryptlen <= AES_BLOCK_SIZE) {

arch/arm64/crypto/aes-glue.c

343

if (req->cryptlen < AES_BLOCK_SIZE)

arch/arm64/crypto/aes-glue.c

350

cbc_blocks * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

358

if (req->cryptlen == AES_BLOCK_SIZE)

arch/arm64/crypto/aes-glue.c

369

req->cryptlen - cbc_blocks * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

393

blocks = walk.nbytes / AES_BLOCK_SIZE;

arch/arm64/crypto/aes-glue.c

400

err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE);

arch/arm64/crypto/aes-glue.c

415

blocks = walk.nbytes / AES_BLOCK_SIZE;

arch/arm64/crypto/aes-glue.c

422

err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE);

arch/arm64/crypto/aes-glue.c

441

u8 buf[AES_BLOCK_SIZE];

arch/arm64/crypto/aes-glue.c

451

if (unlikely(nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/aes-glue.c

455

nbytes &= ~(AES_BLOCK_SIZE - 1);

arch/arm64/crypto/aes-glue.c

461

if (unlikely(nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/aes-glue.c

485

u8 buf[AES_BLOCK_SIZE];

arch/arm64/crypto/aes-glue.c

495

if (unlikely(nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/aes-glue.c

499

nbytes &= ~(AES_BLOCK_SIZE - 1);

arch/arm64/crypto/aes-glue.c

505

if (unlikely(nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/aes-glue.c

520

int tail = req->cryptlen % AES_BLOCK_SIZE;

arch/arm64/crypto/aes-glue.c

526

if (req->cryptlen < AES_BLOCK_SIZE)

arch/arm64/crypto/aes-glue.c

533

AES_BLOCK_SIZE) - 2;

arch/arm64/crypto/aes-glue.c

542

xts_blocks * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

551

for (first = 1; walk.nbytes >= AES_BLOCK_SIZE; first = 0) {

arch/arm64/crypto/aes-glue.c

555

nbytes &= ~(AES_BLOCK_SIZE - 1);

arch/arm64/crypto/aes-glue.c

570

skcipher_request_set_crypt(req, src, dst, AES_BLOCK_SIZE + tail,

arch/arm64/crypto/aes-glue.c

589

int tail = req->cryptlen % AES_BLOCK_SIZE;

arch/arm64/crypto/aes-glue.c

595

if (req->cryptlen < AES_BLOCK_SIZE)

arch/arm64/crypto/aes-glue.c

602

AES_BLOCK_SIZE) - 2;

arch/arm64/crypto/aes-glue.c

611

xts_blocks * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

620

for (first = 1; walk.nbytes >= AES_BLOCK_SIZE; first = 0) {

arch/arm64/crypto/aes-glue.c

624

nbytes &= ~(AES_BLOCK_SIZE - 1);

arch/arm64/crypto/aes-glue.c

639

skcipher_request_set_crypt(req, src, dst, AES_BLOCK_SIZE + tail,

arch/arm64/crypto/aes-glue.c

659

.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

673

.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

679

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

694

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

695

.chunksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

710

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

711

.chunksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

720

.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

726

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

727

.walksize = 2 * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

737

.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

743

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

744

.walksize = 2 * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

753

.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

759

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

796

aes_ecb_encrypt(ctx->consts, (u8[AES_BLOCK_SIZE]){},

arch/arm64/crypto/aes-glue.c

808

static u8 const ks[3][AES_BLOCK_SIZE] = {

arch/arm64/crypto/aes-glue.c

809

{ [0 ... AES_BLOCK_SIZE - 1] = 0x1 },

arch/arm64/crypto/aes-glue.c

810

{ [0 ... AES_BLOCK_SIZE - 1] = 0x2 },

arch/arm64/crypto/aes-glue.c

811

{ [0 ... AES_BLOCK_SIZE - 1] = 0x3 },

arch/arm64/crypto/aes-glue.c

816

u8 key[AES_BLOCK_SIZE];

arch/arm64/crypto/aes-glue.c

835

memset(ctx->dg, 0, AES_BLOCK_SIZE);

arch/arm64/crypto/aes-glue.c

849

in += (blocks - rem) * AES_BLOCK_SIZE;

arch/arm64/crypto/aes-glue.c

858

int blocks = len / AES_BLOCK_SIZE;

arch/arm64/crypto/aes-glue.c

860

len %= AES_BLOCK_SIZE;

arch/arm64/crypto/aes-glue.c

875

memcpy(out, ctx->dg, AES_BLOCK_SIZE);

arch/arm64/crypto/aes-glue.c

887

if (len != AES_BLOCK_SIZE) {

arch/arm64/crypto/aes-glue.c

889

consts += AES_BLOCK_SIZE;

arch/arm64/crypto/aes-glue.c

892

memcpy(out, ctx->dg, AES_BLOCK_SIZE);

arch/arm64/crypto/aes-glue.c

902

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

904

2 * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

907

.digestsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

919

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

921

2 * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

924

.digestsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

935

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

939

.digestsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-neonbs-glue.c

110

while (walk.nbytes >= AES_BLOCK_SIZE) {

arch/arm64/crypto/aes-neonbs-glue.c

111

unsigned int blocks = walk.nbytes / AES_BLOCK_SIZE;

arch/arm64/crypto/aes-neonbs-glue.c

115

walk.stride / AES_BLOCK_SIZE);

arch/arm64/crypto/aes-neonbs-glue.c

121

walk.nbytes - blocks * AES_BLOCK_SIZE);

arch/arm64/crypto/aes-neonbs-glue.c

172

while (walk.nbytes >= AES_BLOCK_SIZE) {

arch/arm64/crypto/aes-neonbs-glue.c

173

unsigned int blocks = walk.nbytes / AES_BLOCK_SIZE;

arch/arm64/crypto/aes-neonbs-glue.c

181

err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE);

arch/arm64/crypto/aes-neonbs-glue.c

195

while (walk.nbytes >= AES_BLOCK_SIZE) {

arch/arm64/crypto/aes-neonbs-glue.c

196

unsigned int blocks = walk.nbytes / AES_BLOCK_SIZE;

arch/arm64/crypto/aes-neonbs-glue.c

200

walk.stride / AES_BLOCK_SIZE);

arch/arm64/crypto/aes-neonbs-glue.c

207

walk.nbytes - blocks * AES_BLOCK_SIZE);

arch/arm64/crypto/aes-neonbs-glue.c

223

int blocks = (walk.nbytes / AES_BLOCK_SIZE) & ~7;

arch/arm64/crypto/aes-neonbs-glue.c

224

int nbytes = walk.nbytes % (8 * AES_BLOCK_SIZE);

arch/arm64/crypto/aes-neonbs-glue.c

233

dst += blocks * AES_BLOCK_SIZE;

arch/arm64/crypto/aes-neonbs-glue.c

234

src += blocks * AES_BLOCK_SIZE;

arch/arm64/crypto/aes-neonbs-glue.c

237

u8 buf[AES_BLOCK_SIZE];

arch/arm64/crypto/aes-neonbs-glue.c

240

if (unlikely(nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/aes-neonbs-glue.c

248

if (unlikely(nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/aes-neonbs-glue.c

290

int tail = req->cryptlen % (8 * AES_BLOCK_SIZE);

arch/arm64/crypto/aes-neonbs-glue.c

300

if (req->cryptlen < AES_BLOCK_SIZE)

arch/arm64/crypto/aes-neonbs-glue.c

304

if (unlikely(tail > 0 && tail < AES_BLOCK_SIZE)) {

arch/arm64/crypto/aes-neonbs-glue.c

306

AES_BLOCK_SIZE) - 2;

arch/arm64/crypto/aes-neonbs-glue.c

313

xts_blocks * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-neonbs-glue.c

325

while (walk.nbytes >= AES_BLOCK_SIZE) {

arch/arm64/crypto/aes-neonbs-glue.c

326

int blocks = (walk.nbytes / AES_BLOCK_SIZE) & ~7;

arch/arm64/crypto/aes-neonbs-glue.c

341

out += blocks * AES_BLOCK_SIZE;

arch/arm64/crypto/aes-neonbs-glue.c

342

in += blocks * AES_BLOCK_SIZE;

arch/arm64/crypto/aes-neonbs-glue.c

343

nbytes -= blocks * AES_BLOCK_SIZE;

arch/arm64/crypto/aes-neonbs-glue.c

367

skcipher_request_set_crypt(req, src, dst, AES_BLOCK_SIZE + tail,

arch/arm64/crypto/aes-neonbs-glue.c

405

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-neonbs-glue.c

411

.walksize = 8 * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-neonbs-glue.c

419

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-neonbs-glue.c

425

.walksize = 8 * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-neonbs-glue.c

426

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-neonbs-glue.c

440

.chunksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-neonbs-glue.c

441

.walksize = 8 * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-neonbs-glue.c

442

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-neonbs-glue.c

450

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-neonbs-glue.c

456

.walksize = 8 * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-neonbs-glue.c

457

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-neonbs-glue.c

60

u8 rk[13 * (8 * AES_BLOCK_SIZE) + 32];

arch/arm64/crypto/aes-neonbs-glue.c

62

} __aligned(AES_BLOCK_SIZE);

arch/arm64/crypto/ghash-ce-glue.c

201

aes_encrypt(&ctx->aes_key, key, (u8[AES_BLOCK_SIZE]){});

arch/arm64/crypto/ghash-ce-glue.c

288

u8 buf[AES_BLOCK_SIZE];

arch/arm64/crypto/ghash-ce-glue.c

311

if (unlikely(nbytes > 0 && nbytes < AES_BLOCK_SIZE)) {

arch/arm64/crypto/ghash-ce-glue.c

315

nbytes &= ~(AES_BLOCK_SIZE - 1);

arch/arm64/crypto/ghash-ce-glue.c

327

if (unlikely(nbytes > 0 && nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/ghash-ce-glue.c

350

u8 otag[AES_BLOCK_SIZE];

arch/arm64/crypto/ghash-ce-glue.c

351

u8 buf[AES_BLOCK_SIZE];

arch/arm64/crypto/ghash-ce-glue.c

379

if (unlikely(nbytes > 0 && nbytes < AES_BLOCK_SIZE)) {

arch/arm64/crypto/ghash-ce-glue.c

383

nbytes &= ~(AES_BLOCK_SIZE - 1);

arch/arm64/crypto/ghash-ce-glue.c

397

if (unlikely(nbytes > 0 && nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/ghash-ce-glue.c

412

u8 iv[AES_BLOCK_SIZE];

arch/arm64/crypto/ghash-ce-glue.c

420

u8 iv[AES_BLOCK_SIZE];

arch/arm64/crypto/ghash-ce-glue.c

450

u8 iv[AES_BLOCK_SIZE];

arch/arm64/crypto/ghash-ce-glue.c

463

u8 iv[AES_BLOCK_SIZE];

arch/arm64/crypto/ghash-ce-glue.c

474

.chunksize = AES_BLOCK_SIZE,

arch/arm64/crypto/ghash-ce-glue.c

475

.maxauthsize = AES_BLOCK_SIZE,

arch/arm64/crypto/ghash-ce-glue.c

490

.chunksize = AES_BLOCK_SIZE,

arch/arm64/crypto/ghash-ce-glue.c

491

.maxauthsize = AES_BLOCK_SIZE,

arch/powerpc/crypto/aes-gcm-p10-glue.c

221

unsigned char ivbuf[AES_BLOCK_SIZE+PPC_ALIGN];

arch/powerpc/crypto/aes-gcm-p10-glue.c

266

u8 buf[AES_BLOCK_SIZE];

arch/powerpc/crypto/aes-gcm-p10-glue.c

268

if (unlikely(nbytes > 0 && nbytes < AES_BLOCK_SIZE))

arch/powerpc/crypto/aes-gcm-p10-glue.c

279

if (unlikely(nbytes > 0 && nbytes < AES_BLOCK_SIZE))

arch/powerpc/crypto/aes-gcm-p10-glue.c

339

u8 iv[AES_BLOCK_SIZE];

arch/powerpc/crypto/aes-gcm-p10-glue.c

352

u8 iv[AES_BLOCK_SIZE];

arch/powerpc/crypto/aes-spe-glue.c

144

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

arch/powerpc/crypto/aes-spe-glue.c

183

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

arch/powerpc/crypto/aes-spe-glue.c

225

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

arch/powerpc/crypto/aes-spe-glue.c

252

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

arch/powerpc/crypto/aes-spe-glue.c

276

int tail = req->cryptlen % AES_BLOCK_SIZE;

arch/powerpc/crypto/aes-spe-glue.c

277

int offset = req->cryptlen - tail - AES_BLOCK_SIZE;

arch/powerpc/crypto/aes-spe-glue.c

279

u8 b[2][AES_BLOCK_SIZE];

arch/powerpc/crypto/aes-spe-glue.c

282

if (req->cryptlen < AES_BLOCK_SIZE)

arch/powerpc/crypto/aes-spe-glue.c

296

scatterwalk_map_and_copy(b[0], req->dst, offset, AES_BLOCK_SIZE, 0);

arch/powerpc/crypto/aes-spe-glue.c

298

scatterwalk_map_and_copy(b[0], req->src, offset + AES_BLOCK_SIZE, tail, 0);

arch/powerpc/crypto/aes-spe-glue.c

301

ppc_encrypt_xts(b[0], b[0], ctx->key_enc, ctx->rounds, AES_BLOCK_SIZE,

arch/powerpc/crypto/aes-spe-glue.c

305

scatterwalk_map_and_copy(b[0], req->dst, offset, AES_BLOCK_SIZE + tail, 1);

arch/powerpc/crypto/aes-spe-glue.c

314

int tail = req->cryptlen % AES_BLOCK_SIZE;

arch/powerpc/crypto/aes-spe-glue.c

315

int offset = req->cryptlen - tail - AES_BLOCK_SIZE;

arch/powerpc/crypto/aes-spe-glue.c

317

u8 b[3][AES_BLOCK_SIZE];

arch/powerpc/crypto/aes-spe-glue.c

321

if (req->cryptlen < AES_BLOCK_SIZE)

arch/powerpc/crypto/aes-spe-glue.c

335

scatterwalk_map_and_copy(b[1], req->src, offset, AES_BLOCK_SIZE + tail, 0);

arch/powerpc/crypto/aes-spe-glue.c

340

AES_BLOCK_SIZE);

arch/powerpc/crypto/aes-spe-glue.c

344

ppc_decrypt_xts(b[1], b[1], ctx->key_dec, ctx->rounds, AES_BLOCK_SIZE,

arch/powerpc/crypto/aes-spe-glue.c

347

memcpy(b[0] + tail, b[1] + tail, AES_BLOCK_SIZE - tail);

arch/powerpc/crypto/aes-spe-glue.c

348

ppc_decrypt_xts(b[0], b[0], ctx->key_dec, ctx->rounds, AES_BLOCK_SIZE,

arch/powerpc/crypto/aes-spe-glue.c

352

scatterwalk_map_and_copy(b[0], req->dst, offset, AES_BLOCK_SIZE + tail, 1);

arch/powerpc/crypto/aes-spe-glue.c

370

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/powerpc/crypto/aes-spe-glue.c

382

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/powerpc/crypto/aes-spe-glue.c

387

.ivsize = AES_BLOCK_SIZE,

arch/powerpc/crypto/aes-spe-glue.c

400

.ivsize = AES_BLOCK_SIZE,

arch/powerpc/crypto/aes-spe-glue.c

404

.chunksize = AES_BLOCK_SIZE,

arch/powerpc/crypto/aes-spe-glue.c

409

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/powerpc/crypto/aes-spe-glue.c

414

.ivsize = AES_BLOCK_SIZE,

arch/powerpc/crypto/aes_cbc.c

106

ret = skcipher_walk_done(&walk, nbytes % AES_BLOCK_SIZE);

arch/powerpc/crypto/aes_cbc.c

127

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/powerpc/crypto/aes_cbc.c

136

.ivsize = AES_BLOCK_SIZE,

arch/powerpc/crypto/aes_cbc.c

99

round_down(nbytes, AES_BLOCK_SIZE),

arch/powerpc/crypto/aes_ctr.c

111

while ((nbytes = walk.nbytes) >= AES_BLOCK_SIZE) {

arch/powerpc/crypto/aes_ctr.c

117

nbytes / AES_BLOCK_SIZE,

arch/powerpc/crypto/aes_ctr.c

124

crypto_inc(walk.iv, AES_BLOCK_SIZE);

arch/powerpc/crypto/aes_ctr.c

125

} while ((nbytes -= AES_BLOCK_SIZE) >= AES_BLOCK_SIZE);

arch/powerpc/crypto/aes_ctr.c

151

.ivsize = AES_BLOCK_SIZE,

arch/powerpc/crypto/aes_ctr.c

152

.chunksize = AES_BLOCK_SIZE,

arch/powerpc/crypto/aes_ctr.c

78

u8 keystream[AES_BLOCK_SIZE];

arch/powerpc/crypto/aes_ctr.c

91

crypto_inc(ctrblk, AES_BLOCK_SIZE);

arch/powerpc/crypto/aes_xts.c

124

round_down(nbytes, AES_BLOCK_SIZE),

arch/powerpc/crypto/aes_xts.c

129

round_down(nbytes, AES_BLOCK_SIZE),

arch/powerpc/crypto/aes_xts.c

135

ret = skcipher_walk_done(&walk, nbytes % AES_BLOCK_SIZE);

arch/powerpc/crypto/aes_xts.c

156

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/powerpc/crypto/aes_xts.c

165

.ivsize = AES_BLOCK_SIZE,

arch/powerpc/crypto/aes_xts.c

88

u8 tweak[AES_BLOCK_SIZE];

arch/powerpc/crypto/aes_xts.c

91

if (req->cryptlen < AES_BLOCK_SIZE)

arch/riscv/crypto/aes-riscv64-glue.c

104

nbytes & ~(AES_BLOCK_SIZE - 1));

arch/riscv/crypto/aes-riscv64-glue.c

108

nbytes & ~(AES_BLOCK_SIZE - 1));

arch/riscv/crypto/aes-riscv64-glue.c

110

err = skcipher_walk_done(&walk, nbytes & (AES_BLOCK_SIZE - 1));

arch/riscv/crypto/aes-riscv64-glue.c

142

nbytes & ~(AES_BLOCK_SIZE - 1),

arch/riscv/crypto/aes-riscv64-glue.c

147

nbytes & ~(AES_BLOCK_SIZE - 1),

arch/riscv/crypto/aes-riscv64-glue.c

150

err = skcipher_walk_done(&walk, nbytes & (AES_BLOCK_SIZE - 1));

arch/riscv/crypto/aes-riscv64-glue.c

179

if (req->cryptlen < AES_BLOCK_SIZE)

arch/riscv/crypto/aes-riscv64-glue.c

192

cbc_len = round_down(req->cryptlen - AES_BLOCK_SIZE - 1,

arch/riscv/crypto/aes-riscv64-glue.c

193

AES_BLOCK_SIZE);

arch/riscv/crypto/aes-riscv64-glue.c

248

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

arch/riscv/crypto/aes-riscv64-glue.c

249

nblocks = nbytes / AES_BLOCK_SIZE;

arch/riscv/crypto/aes-riscv64-glue.c

252

nblocks = DIV_ROUND_UP(nbytes, AES_BLOCK_SIZE);

arch/riscv/crypto/aes-riscv64-glue.c

270

(nblocks - ctr32) * AES_BLOCK_SIZE);

arch/riscv/crypto/aes-riscv64-glue.c

31

u8 iv[AES_BLOCK_SIZE]);

arch/riscv/crypto/aes-riscv64-glue.c

313

int tail = req->cryptlen % AES_BLOCK_SIZE;

arch/riscv/crypto/aes-riscv64-glue.c

320

if (req->cryptlen < AES_BLOCK_SIZE)

arch/riscv/crypto/aes-riscv64-glue.c

34

u8 iv[AES_BLOCK_SIZE]);

arch/riscv/crypto/aes-riscv64-glue.c

343

req->cryptlen - tail - AES_BLOCK_SIZE,

arch/riscv/crypto/aes-riscv64-glue.c

355

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

arch/riscv/crypto/aes-riscv64-glue.c

379

skcipher_request_set_crypt(req, src, dst, AES_BLOCK_SIZE + tail,

arch/riscv/crypto/aes-riscv64-glue.c

38

const u8 iv[AES_BLOCK_SIZE], bool enc);

arch/riscv/crypto/aes-riscv64-glue.c

419

.walksize = 8 * AES_BLOCK_SIZE, /* matches LMUL=8 */

arch/riscv/crypto/aes-riscv64-glue.c

42

u8 iv[AES_BLOCK_SIZE]);

arch/riscv/crypto/aes-riscv64-glue.c

421

.cra_blocksize = AES_BLOCK_SIZE,

arch/riscv/crypto/aes-riscv64-glue.c

434

.ivsize = AES_BLOCK_SIZE,

arch/riscv/crypto/aes-riscv64-glue.c

436

.cra_blocksize = AES_BLOCK_SIZE,

arch/riscv/crypto/aes-riscv64-glue.c

449

.ivsize = AES_BLOCK_SIZE,

arch/riscv/crypto/aes-riscv64-glue.c

450

.walksize = 4 * AES_BLOCK_SIZE, /* matches LMUL=4 */

arch/riscv/crypto/aes-riscv64-glue.c

452

.cra_blocksize = AES_BLOCK_SIZE,

arch/riscv/crypto/aes-riscv64-glue.c

468

.ivsize = AES_BLOCK_SIZE,

arch/riscv/crypto/aes-riscv64-glue.c

469

.chunksize = AES_BLOCK_SIZE,

arch/riscv/crypto/aes-riscv64-glue.c

47

u8 tweak[AES_BLOCK_SIZE]);

arch/riscv/crypto/aes-riscv64-glue.c

470

.walksize = 4 * AES_BLOCK_SIZE, /* matches LMUL=4 */

arch/riscv/crypto/aes-riscv64-glue.c

487

.ivsize = AES_BLOCK_SIZE,

arch/riscv/crypto/aes-riscv64-glue.c

488

.chunksize = AES_BLOCK_SIZE,

arch/riscv/crypto/aes-riscv64-glue.c

489

.walksize = 4 * AES_BLOCK_SIZE, /* matches LMUL=4 */

arch/riscv/crypto/aes-riscv64-glue.c

491

.cra_blocksize = AES_BLOCK_SIZE,

arch/riscv/crypto/aes-riscv64-glue.c

52

u8 tweak[AES_BLOCK_SIZE]);

arch/s390/crypto/aes_s390.c

134

n = nbytes & ~(AES_BLOCK_SIZE - 1);

arch/s390/crypto/aes_s390.c

183

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/s390/crypto/aes_s390.c

224

u8 iv[AES_BLOCK_SIZE];

arch/s390/crypto/aes_s390.c

234

memcpy(param.iv, walk.iv, AES_BLOCK_SIZE);

arch/s390/crypto/aes_s390.c

238

n = nbytes & ~(AES_BLOCK_SIZE - 1);

arch/s390/crypto/aes_s390.c

241

memcpy(walk.iv, param.iv, AES_BLOCK_SIZE);

arch/s390/crypto/aes_s390.c

263

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/s390/crypto/aes_s390.c

270

.ivsize = AES_BLOCK_SIZE,

arch/s390/crypto/aes_s390.c

335

if (req->cryptlen < AES_BLOCK_SIZE)

arch/s390/crypto/aes_s390.c

338

if (unlikely(!xts_ctx->fc || (req->cryptlen % AES_BLOCK_SIZE) != 0)) {

arch/s390/crypto/aes_s390.c

364

n = nbytes & ~(AES_BLOCK_SIZE - 1);

arch/s390/crypto/aes_s390.c

414

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/s390/crypto/aes_s390.c

421

.ivsize = AES_BLOCK_SIZE,

arch/s390/crypto/aes_s390.c

468

if (req->cryptlen < AES_BLOCK_SIZE)

arch/s390/crypto/aes_s390.c

471

if (unlikely(!xts_ctx->fc || (req->cryptlen % AES_BLOCK_SIZE) != 0)) {

arch/s390/crypto/aes_s390.c

487

memcpy(fxts_param.tweak, req->iv, AES_BLOCK_SIZE);

arch/s390/crypto/aes_s390.c

492

n = nbytes & ~(AES_BLOCK_SIZE - 1);

arch/s390/crypto/aes_s390.c

516

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/s390/crypto/aes_s390.c

523

.ivsize = AES_BLOCK_SIZE,

arch/s390/crypto/aes_s390.c

555

memcpy(ctrptr, iv, AES_BLOCK_SIZE);

arch/s390/crypto/aes_s390.c

556

n = (nbytes > PAGE_SIZE) ? PAGE_SIZE : nbytes & ~(AES_BLOCK_SIZE - 1);

arch/s390/crypto/aes_s390.c

557

for (i = (n / AES_BLOCK_SIZE) - 1; i > 0; i--) {

arch/s390/crypto/aes_s390.c

558

memcpy(ctrptr + AES_BLOCK_SIZE, ctrptr, AES_BLOCK_SIZE);

arch/s390/crypto/aes_s390.c

559

crypto_inc(ctrptr + AES_BLOCK_SIZE, AES_BLOCK_SIZE);

arch/s390/crypto/aes_s390.c

560

ctrptr += AES_BLOCK_SIZE;

arch/s390/crypto/aes_s390.c

569

u8 buf[AES_BLOCK_SIZE], *ctrptr;

arch/s390/crypto/aes_s390.c

580

while ((nbytes = walk.nbytes) >= AES_BLOCK_SIZE) {

arch/s390/crypto/aes_s390.c

581

n = AES_BLOCK_SIZE;

arch/s390/crypto/aes_s390.c

583

if (nbytes >= 2*AES_BLOCK_SIZE && locked)

arch/s390/crypto/aes_s390.c

585

ctrptr = (n > AES_BLOCK_SIZE) ? ctrblk : walk.iv;

arch/s390/crypto/aes_s390.c

589

memcpy(walk.iv, ctrptr + n - AES_BLOCK_SIZE,

arch/s390/crypto/aes_s390.c

590

AES_BLOCK_SIZE);

arch/s390/crypto/aes_s390.c

591

crypto_inc(walk.iv, AES_BLOCK_SIZE);

arch/s390/crypto/aes_s390.c

600

memset(buf, 0, AES_BLOCK_SIZE);

arch/s390/crypto/aes_s390.c

603

AES_BLOCK_SIZE, walk.iv);

arch/s390/crypto/aes_s390.c

605

crypto_inc(walk.iv, AES_BLOCK_SIZE);

arch/s390/crypto/aes_s390.c

624

.ivsize = AES_BLOCK_SIZE,

arch/s390/crypto/aes_s390.c

628

.chunksize = AES_BLOCK_SIZE,

arch/s390/crypto/aes_s390.c

67

u8 buf[AES_BLOCK_SIZE];

arch/s390/crypto/aes_s390.c

728

n = min(gw->walk_bytes, AES_BLOCK_SIZE - gw->buf_bytes);

arch/s390/crypto/aes_s390.c

835

u8 h[AES_BLOCK_SIZE]; /* Hash-subkey */

arch/s390/crypto/aes_s390.c

868

aadlen > 0 ? aadlen : pclen, AES_BLOCK_SIZE);

arch/s390/crypto/aes_s390.c

881

~(AES_BLOCK_SIZE - 1);

arch/s390/crypto/aes_s390.c

884

aad_bytes = bytes & ~(AES_BLOCK_SIZE - 1);

arch/s390/crypto/aes_s390.c

935

.chunksize = AES_BLOCK_SIZE,

arch/s390/crypto/paes_s390.c

1013

memset(buf, 0, AES_BLOCK_SIZE);

arch/s390/crypto/paes_s390.c

1017

buf, AES_BLOCK_SIZE,

arch/s390/crypto/paes_s390.c

1018

walk->iv) == AES_BLOCK_SIZE)

arch/s390/crypto/paes_s390.c

1032

crypto_inc(walk->iv, AES_BLOCK_SIZE);

arch/s390/crypto/paes_s390.c

1161

.ivsize = AES_BLOCK_SIZE,

arch/s390/crypto/paes_s390.c

1165

.chunksize = AES_BLOCK_SIZE,

arch/s390/crypto/paes_s390.c

1310

n = nbytes & ~(AES_BLOCK_SIZE - 1);

arch/s390/crypto/paes_s390.c

1404

n = nbytes & ~(AES_BLOCK_SIZE - 1);

arch/s390/crypto/paes_s390.c

1596

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/s390/crypto/paes_s390.c

1604

.ivsize = AES_BLOCK_SIZE,

arch/s390/crypto/paes_s390.c

432

n = nbytes & ~(AES_BLOCK_SIZE - 1);

arch/s390/crypto/paes_s390.c

579

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/s390/crypto/paes_s390.c

601

u8 iv[AES_BLOCK_SIZE];

arch/s390/crypto/paes_s390.c

687

memcpy(param->iv, walk->iv, AES_BLOCK_SIZE);

arch/s390/crypto/paes_s390.c

696

n = nbytes & ~(AES_BLOCK_SIZE - 1);

arch/s390/crypto/paes_s390.c

700

memcpy(walk->iv, param->iv, AES_BLOCK_SIZE);

arch/s390/crypto/paes_s390.c

845

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/s390/crypto/paes_s390.c

853

.ivsize = AES_BLOCK_SIZE,

arch/s390/crypto/paes_s390.c

925

memcpy(ctrptr, iv, AES_BLOCK_SIZE);

arch/s390/crypto/paes_s390.c

926

n = (nbytes > PAGE_SIZE) ? PAGE_SIZE : nbytes & ~(AES_BLOCK_SIZE - 1);

arch/s390/crypto/paes_s390.c

927

for (i = (n / AES_BLOCK_SIZE) - 1; i > 0; i--) {

arch/s390/crypto/paes_s390.c

928

memcpy(ctrptr + AES_BLOCK_SIZE, ctrptr, AES_BLOCK_SIZE);

arch/s390/crypto/paes_s390.c

929

crypto_inc(ctrptr + AES_BLOCK_SIZE, AES_BLOCK_SIZE);

arch/s390/crypto/paes_s390.c

930

ctrptr += AES_BLOCK_SIZE;

arch/s390/crypto/paes_s390.c

941

u8 buf[AES_BLOCK_SIZE], *ctrptr;

arch/s390/crypto/paes_s390.c

976

while ((nbytes = walk->nbytes) >= AES_BLOCK_SIZE) {

arch/s390/crypto/paes_s390.c

977

n = AES_BLOCK_SIZE;

arch/s390/crypto/paes_s390.c

978

if (nbytes >= 2 * AES_BLOCK_SIZE && locked)

arch/s390/crypto/paes_s390.c

980

ctrptr = (n > AES_BLOCK_SIZE) ? ctrblk : walk->iv;

arch/s390/crypto/paes_s390.c

985

memcpy(walk->iv, ctrptr + k - AES_BLOCK_SIZE,

arch/s390/crypto/paes_s390.c

986

AES_BLOCK_SIZE);

arch/s390/crypto/paes_s390.c

987

crypto_inc(walk->iv, AES_BLOCK_SIZE);

arch/sparc/crypto/aes_glue.c

133

round_down(nbytes, AES_BLOCK_SIZE));

arch/sparc/crypto/aes_glue.c

134

err = skcipher_walk_done(&walk, nbytes % AES_BLOCK_SIZE);

arch/sparc/crypto/aes_glue.c

158

round_down(nbytes, AES_BLOCK_SIZE));

arch/sparc/crypto/aes_glue.c

159

err = skcipher_walk_done(&walk, nbytes % AES_BLOCK_SIZE);

arch/sparc/crypto/aes_glue.c

182

round_down(nbytes, AES_BLOCK_SIZE),

arch/sparc/crypto/aes_glue.c

184

err = skcipher_walk_done(&walk, nbytes % AES_BLOCK_SIZE);

arch/sparc/crypto/aes_glue.c

208

round_down(nbytes, AES_BLOCK_SIZE),

arch/sparc/crypto/aes_glue.c

210

err = skcipher_walk_done(&walk, nbytes % AES_BLOCK_SIZE);

arch/sparc/crypto/aes_glue.c

221

u64 keystream[AES_BLOCK_SIZE / sizeof(u64)];

arch/sparc/crypto/aes_glue.c

227

keystream, AES_BLOCK_SIZE);

arch/sparc/crypto/aes_glue.c

229

crypto_inc(ctrblk, AES_BLOCK_SIZE);

arch/sparc/crypto/aes_glue.c

245

while ((nbytes = walk.nbytes) >= AES_BLOCK_SIZE) {

arch/sparc/crypto/aes_glue.c

248

round_down(nbytes, AES_BLOCK_SIZE),

arch/sparc/crypto/aes_glue.c

250

err = skcipher_walk_done(&walk, nbytes % AES_BLOCK_SIZE);

arch/sparc/crypto/aes_glue.c

265

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/sparc/crypto/aes_glue.c

278

.base.cra_blocksize = AES_BLOCK_SIZE,

arch/sparc/crypto/aes_glue.c

284

.ivsize = AES_BLOCK_SIZE,

arch/sparc/crypto/aes_glue.c

298

.ivsize = AES_BLOCK_SIZE,

arch/sparc/crypto/aes_glue.c

302

.chunksize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

136

nbytes &= AES_BLOCK_SIZE - 1;

arch/x86/crypto/aesni-intel_glue.c

1388

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

1391

le_ctr[0] += nbytes / AES_BLOCK_SIZE;

arch/x86/crypto/aesni-intel_glue.c

1479

.chunksize = AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

1495

.chunksize = AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

158

nbytes &= AES_BLOCK_SIZE - 1;

arch/x86/crypto/aesni-intel_glue.c

180

nbytes &= AES_BLOCK_SIZE - 1;

arch/x86/crypto/aesni-intel_glue.c

202

nbytes &= AES_BLOCK_SIZE - 1;

arch/x86/crypto/aesni-intel_glue.c

213

int cbc_blocks = DIV_ROUND_UP(req->cryptlen, AES_BLOCK_SIZE) - 2;

arch/x86/crypto/aesni-intel_glue.c

224

if (req->cryptlen <= AES_BLOCK_SIZE) {

arch/x86/crypto/aesni-intel_glue.c

225

if (req->cryptlen < AES_BLOCK_SIZE)

arch/x86/crypto/aesni-intel_glue.c

232

cbc_blocks * AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

239

if (req->cryptlen == AES_BLOCK_SIZE)

arch/x86/crypto/aesni-intel_glue.c

250

req->cryptlen - cbc_blocks * AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

269

int cbc_blocks = DIV_ROUND_UP(req->cryptlen, AES_BLOCK_SIZE) - 2;

arch/x86/crypto/aesni-intel_glue.c

280

if (req->cryptlen <= AES_BLOCK_SIZE) {

arch/x86/crypto/aesni-intel_glue.c

281

if (req->cryptlen < AES_BLOCK_SIZE)

arch/x86/crypto/aesni-intel_glue.c

288

cbc_blocks * AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

295

if (req->cryptlen == AES_BLOCK_SIZE)

arch/x86/crypto/aesni-intel_glue.c

306

req->cryptlen - cbc_blocks * AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

327

u8 keystream[AES_BLOCK_SIZE];

arch/x86/crypto/aesni-intel_glue.c

347

crypto_inc(walk.iv, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

379

u8 iv[AES_BLOCK_SIZE]);

arch/x86/crypto/aesni-intel_glue.c

382

u8 tweak[AES_BLOCK_SIZE]);

arch/x86/crypto/aesni-intel_glue.c

390

int tail = req->cryptlen % AES_BLOCK_SIZE;

arch/x86/crypto/aesni-intel_glue.c

409

req->cryptlen - tail - AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

420

walk.nbytes & ~(AES_BLOCK_SIZE - 1), req->iv);

arch/x86/crypto/aesni-intel_glue.c

423

walk.nbytes & (AES_BLOCK_SIZE - 1));

arch/x86/crypto/aesni-intel_glue.c

43

#define AES_BLOCK_MASK (~(AES_BLOCK_SIZE - 1))

arch/x86/crypto/aesni-intel_glue.c

435

skcipher_request_set_crypt(req, src, dst, AES_BLOCK_SIZE + tail,

arch/x86/crypto/aesni-intel_glue.c

458

if (unlikely(req->cryptlen < AES_BLOCK_SIZE))

arch/x86/crypto/aesni-intel_glue.c

484

u8 iv[AES_BLOCK_SIZE])

arch/x86/crypto/aesni-intel_glue.c

491

u8 tweak[AES_BLOCK_SIZE])

arch/x86/crypto/aesni-intel_glue.c

498

u8 tweak[AES_BLOCK_SIZE])

arch/x86/crypto/aesni-intel_glue.c

519

.cra_blocksize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

533

.cra_blocksize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

539

.ivsize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

548

.cra_blocksize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

554

.ivsize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

555

.walksize = 2 * AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

571

.ivsize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

572

.chunksize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

582

.cra_blocksize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

588

.ivsize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

589

.walksize = 2 * AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

598

u8 iv[AES_BLOCK_SIZE]);

arch/x86/crypto/aesni-intel_glue.c

623

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

624

nblocks = nbytes / AES_BLOCK_SIZE;

arch/x86/crypto/aesni-intel_glue.c

627

nblocks = DIV_ROUND_UP(nbytes, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

643

p1_nbytes = min(nbytes, (nblocks - ctr64) * AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

669

const u8 iv[AES_BLOCK_SIZE], u64 ctr))

arch/x86/crypto/aesni-intel_glue.c

681

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

688

ctr += DIV_ROUND_UP(nbytes, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

698

u8 *dst, int len, u8 tweak[AES_BLOCK_SIZE]); \

arch/x86/crypto/aesni-intel_glue.c

701

u8 *dst, int len, u8 tweak[AES_BLOCK_SIZE]); \

arch/x86/crypto/aesni-intel_glue.c

725

const u8 iv[AES_BLOCK_SIZE], u64 ctr); \

arch/x86/crypto/aesni-intel_glue.c

736

.base.cra_blocksize = AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

741

.ivsize = AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

742

.walksize = 2 * AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

755

.ivsize = AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

756

.chunksize = AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

769

.ivsize = AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

770

.chunksize = AES_BLOCK_SIZE, \

crypto/aes.c

41

.cra_blocksize = AES_BLOCK_SIZE,

drivers/char/tpm/tpm2-sessions.c

114

u8 scratch[AES_KEY_BYTES + AES_BLOCK_SIZE];

drivers/char/tpm/tpm2-sessions.c

676

auth->tpm_nonce, AES_KEY_BYTES + AES_BLOCK_SIZE,

drivers/char/tpm/tpm2-sessions.c

857

auth->our_nonce, AES_KEY_BYTES + AES_BLOCK_SIZE,

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-core.c

120

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-core.c

94

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-core.c

99

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/allwinner/sun4i-ss/sun4i-ss.h

186

u8 backup_iv[AES_BLOCK_SIZE];

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-core.c

313

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-core.c

325

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-core.c

343

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/allwinner/sun8i-ce/sun8i-ce.h

277

u8 bounce_iv[AES_BLOCK_SIZE] __aligned(sizeof(u32));

drivers/crypto/allwinner/sun8i-ce/sun8i-ce.h

278

u8 backup_iv[AES_BLOCK_SIZE];

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-core.c

177

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-core.c

189

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-core.c

207

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-core.c

556

ss->flows[i].biv = devm_kmalloc(ss->dev, AES_BLOCK_SIZE,

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-core.c

564

ss->flows[i].iv[j] = devm_kmalloc(ss->dev, AES_BLOCK_SIZE,

drivers/crypto/amcc/crypto4xx_alg.c

242

unsigned int nblks = ALIGN(req->cryptlen, AES_BLOCK_SIZE) /

drivers/crypto/amcc/crypto4xx_alg.c

243

AES_BLOCK_SIZE;

drivers/crypto/amcc/crypto4xx_alg.c

320

if (len < AES_BLOCK_SIZE)

drivers/crypto/amcc/crypto4xx_alg.c

74

if (check_blocksize && !IS_ALIGNED(req->cryptlen, AES_BLOCK_SIZE))

drivers/crypto/amcc/crypto4xx_core.c

1154

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/amcc/crypto4xx_core.c

1215

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/amcc/crypto4xx_core.c

1236

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/amcc/crypto4xx_core.c

548

u32 icv[AES_BLOCK_SIZE];

drivers/crypto/amcc/crypto4xx_core.c

682

&& (datalen % AES_BLOCK_SIZE);

drivers/crypto/amlogic/amlogic-gxl-core.c

57

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/amlogic/amlogic-gxl-core.c

69

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/amlogic/amlogic-gxl-core.c

86

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/aspeed/aspeed-hace-crypto.c

117

AES_BLOCK_SIZE);

drivers/crypto/aspeed/aspeed-hace-crypto.c

392

AES_BLOCK_SIZE);

drivers/crypto/aspeed/aspeed-hace-crypto.c

545

if (!IS_ALIGNED(req->cryptlen, AES_BLOCK_SIZE))

drivers/crypto/aspeed/aspeed-hace-crypto.c

60

!IS_ALIGNED(areq->cryptlen, AES_BLOCK_SIZE))

drivers/crypto/aspeed/aspeed-hace-crypto.c

688

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/aspeed/aspeed-hace-crypto.c

700

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/aspeed/aspeed-hace-crypto.c

715

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/aspeed/aspeed-hace-crypto.c

836

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

1015

crypto_inc((u8 *)ctx->iv, AES_BLOCK_SIZE);

drivers/crypto/atmel-aes.c

1039

memcpy(ctx->iv, req->iv, AES_BLOCK_SIZE);

drivers/crypto/atmel-aes.c

107

__be32 iv[AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/atmel-aes.c

1088

ctx->block_size = AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

1189

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

120

__be32 j0[AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/atmel-aes.c

1202

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

121

u32 tag[AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/atmel-aes.c

1211

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

122

__be32 ghash[AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/atmel-aes.c

1225

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

1294

dd->datalen -= AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

1335

padlen = atmel_aes_padlen(ivsize, AES_BLOCK_SIZE);

drivers/crypto/atmel-aes.c

1336

datalen = ivsize + padlen + AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

1395

padlen = atmel_aes_padlen(req->assoclen, AES_BLOCK_SIZE);

drivers/crypto/atmel-aes.c

1418

dd->datalen -= AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

146

u8 lastc[AES_BLOCK_SIZE];

drivers/crypto/atmel-aes.c

1476

return atmel_aes_gcm_ghash(dd, (const u32 *)data, AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

1534

ctx->block_size = AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

1598

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

1649

u32 tweak[AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/atmel-aes.c

1650

static const __le32 one[AES_BLOCK_SIZE / sizeof(u32)] = {cpu_to_le32(1), };

drivers/crypto/atmel-aes.c

1661

for (i = 0; i < AES_BLOCK_SIZE/2; ++i)

drivers/crypto/atmel-aes.c

1662

swap(tweak_bytes[i], tweak_bytes[AES_BLOCK_SIZE - 1 - i]);

drivers/crypto/atmel-aes.c

1744

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

1751

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

1827

__be32 iv[AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/atmel-aes.c

2016

ctx->block_size = AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

2039

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2045

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2055

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2061

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2071

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2077

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2087

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2093

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2103

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2109

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2122

dd->buflen &= ~(AES_BLOCK_SIZE - 1);

drivers/crypto/atmel-aes.c

383

atmel_aes_read_n(dd, offset, value, SIZE_IN_WORDS(AES_BLOCK_SIZE));

drivers/crypto/atmel-aes.c

389

atmel_aes_write_n(dd, offset, value, SIZE_IN_WORDS(AES_BLOCK_SIZE));

drivers/crypto/atmel-aes.c

512

crypto_inc((u8 *)ctx->iv, AES_BLOCK_SIZE);

drivers/crypto/atmel-aes.c

595

dd->datalen -= AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

597

if (dd->datalen < AES_BLOCK_SIZE)

drivers/crypto/atmel-aes.c

626

size_t padlen = atmel_aes_padlen(len, AES_BLOCK_SIZE);

drivers/crypto/atmel-aes.c

851

case AES_BLOCK_SIZE:

drivers/crypto/atmel-aes.c

951

dd->ctx->block_size != AES_BLOCK_SIZE);

drivers/crypto/atmel-aes.c

987

ctx->blocks = DIV_ROUND_UP(datalen, AES_BLOCK_SIZE);

drivers/crypto/atmel-aes.c

996

datalen = AES_BLOCK_SIZE * (0x10000 - start);

drivers/crypto/axis/artpec6_crypto.c

1184

unsigned int nblks = ALIGN(req->cryptlen, AES_BLOCK_SIZE) /

drivers/crypto/axis/artpec6_crypto.c

1185

AES_BLOCK_SIZE;

drivers/crypto/axis/artpec6_crypto.c

1289

if (req->cryptlen < AES_BLOCK_SIZE)

drivers/crypto/axis/artpec6_crypto.c

1802

size_t pad = ALIGN(areq->cryptlen, AES_BLOCK_SIZE) -

drivers/crypto/axis/artpec6_crypto.c

2007

req_ctx->decryption_tag, AES_BLOCK_SIZE, false);

drivers/crypto/axis/artpec6_crypto.c

2022

if (authsize < AES_BLOCK_SIZE) {

drivers/crypto/axis/artpec6_crypto.c

2023

count = AES_BLOCK_SIZE - authsize;

drivers/crypto/axis/artpec6_crypto.c

2166

cipher_req->cryptlen - AES_BLOCK_SIZE,

drivers/crypto/axis/artpec6_crypto.c

2167

AES_BLOCK_SIZE, 0);

drivers/crypto/axis/artpec6_crypto.c

2178

cipher_req->cryptlen - AES_BLOCK_SIZE,

drivers/crypto/axis/artpec6_crypto.c

2179

AES_BLOCK_SIZE, 0);

drivers/crypto/axis/artpec6_crypto.c

2194

u8 input_tag[AES_BLOCK_SIZE];

drivers/crypto/axis/artpec6_crypto.c

2706

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/axis/artpec6_crypto.c

2735

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/axis/artpec6_crypto.c

2750

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/axis/artpec6_crypto.c

2757

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/axis/artpec6_crypto.c

2795

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/axis/artpec6_crypto.c

336

__u8 J0[AES_BLOCK_SIZE];

drivers/crypto/axis/artpec6_crypto.c

344

__u8 decryption_tag[AES_BLOCK_SIZE] ____cacheline_aligned;

drivers/crypto/bcm/cipher.c

1809

((ctx->max_payload % AES_BLOCK_SIZE) != 0));

drivers/crypto/bcm/cipher.c

3029

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3034

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3052

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3057

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3075

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3080

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3098

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3103

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3121

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3126

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3144

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3150

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3169

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3175

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3194

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3200

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3596

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3599

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3615

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3634

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3637

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3653

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

3656

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

4048

.halg.digestsize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

4052

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

4067

.halg.digestsize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.c

4071

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/bcm/cipher.h

132

u8 iv_ctr[ALIGN(2 * AES_BLOCK_SIZE, SPU_MSG_ALIGN)];

drivers/crypto/bcm/cipher.h

167

u8 gcmpad[ALIGN(AES_BLOCK_SIZE, SPU_MSG_ALIGN)];

drivers/crypto/bcm/cipher.h

37

#define MAX_IV_SIZE AES_BLOCK_SIZE

drivers/crypto/caam/caamalg.c

1978

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

1987

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

1999

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2006

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2063

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2064

.chunksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2087

.chunksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2104

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2111

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2141

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2187

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2209

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2232

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2393

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2399

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2418

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2424

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2443

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2449

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2468

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2474

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2493

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2499

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2518

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2524

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2543

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2549

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2568

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2574

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2593

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2599

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2618

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2624

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2643

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2649

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2668

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg.c

2674

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1487

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1494

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1542

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1543

.chunksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1563

.chunksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1577

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1584

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1603

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1622

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1642

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1656

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1662

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1678

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1684

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1700

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1706

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1722

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1728

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1744

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1750

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1766

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1772

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1788

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1794

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1811

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1817

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1833

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1839

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1856

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1862

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1878

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1884

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1901

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi.c

1907

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1681

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1688

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1736

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1737

.chunksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1757

.chunksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1771

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1778

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1813

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1832

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1852

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1866

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1872

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1888

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1894

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1910

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1916

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1932

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1938

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1954

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1960

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1976

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1982

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1998

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2004

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2021

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2027

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2043

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2049

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2066

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2072

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2088

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2094

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2111

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2117

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamhash.c

1717

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamhash.c

1728

.digestsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamhash.c

1736

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamhash.c

1747

.digestsize = AES_BLOCK_SIZE,

drivers/crypto/cavium/cpt/cptvf_algs.c

338

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/cavium/cpt/cptvf_algs.c

346

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/cavium/cpt/cptvf_algs.c

356

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/cavium/cpt/cptvf_algs.c

364

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/cavium/cpt/cptvf_algs.c

374

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/cavium/nitrox/nitrox_aead.c

537

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/cavium/nitrox/nitrox_aead.c

556

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/cavium/nitrox/nitrox_req.h

134

u8 iv[AES_BLOCK_SIZE];

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

390

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

397

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

409

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

416

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

428

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

435

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

466

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

473

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccp/ccp-crypto-aes-cmac.c

165

rctx->cmd.u.aes.iv_len = AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-crypto-aes-cmac.c

375

halg->digestsize = AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-crypto-aes-cmac.c

385

base->cra_blocksize = AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-crypto-aes-galois.c

108

rctx->iv[AES_BLOCK_SIZE - 1] = 1;

drivers/crypto/ccp/ccp-crypto-aes-galois.c

112

iv_len = AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-crypto-aes-galois.c

172

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ccp/ccp-crypto-aes-galois.c

178

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccp/ccp-crypto-aes-galois.c

203

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccp/ccp-crypto-aes-xts.c

164

memcpy(rctx->iv, req->iv, AES_BLOCK_SIZE);

drivers/crypto/ccp/ccp-crypto-aes-xts.c

165

sg_init_one(&rctx->iv_sg, rctx->iv, AES_BLOCK_SIZE);

drivers/crypto/ccp/ccp-crypto-aes-xts.c

177

rctx->cmd.u.xts.iv_len = AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-crypto-aes-xts.c

249

alg->base.cra_blocksize = AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-crypto-aes-xts.c

260

alg->ivsize = AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-crypto-aes-xts.c

70

memcpy(req->iv, rctx->iv, AES_BLOCK_SIZE);

drivers/crypto/ccp/ccp-crypto-aes.c

217

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccp/ccp-crypto-aes.c

257

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccp/ccp-crypto-aes.c

266

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccp/ccp-crypto-aes.c

267

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccp/ccp-crypto-aes.c

276

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccp/ccp-crypto-aes.c

34

memcpy(req->iv, rctx->iv, AES_BLOCK_SIZE);

drivers/crypto/ccp/ccp-crypto-aes.c

80

(req->cryptlen & (AES_BLOCK_SIZE - 1)))

drivers/crypto/ccp/ccp-crypto-aes.c

87

memcpy(rctx->iv, req->iv, AES_BLOCK_SIZE);

drivers/crypto/ccp/ccp-crypto-aes.c

89

iv_len = AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-crypto.h

109

u8 k1[AES_BLOCK_SIZE];

drivers/crypto/ccp/ccp-crypto.h

110

u8 k2[AES_BLOCK_SIZE];

drivers/crypto/ccp/ccp-crypto.h

115

u8 iv[AES_BLOCK_SIZE];

drivers/crypto/ccp/ccp-crypto.h

118

u8 tag[AES_BLOCK_SIZE];

drivers/crypto/ccp/ccp-crypto.h

122

u8 rfc3686_iv[AES_BLOCK_SIZE];

drivers/crypto/ccp/ccp-crypto.h

142

u8 iv[AES_BLOCK_SIZE];

drivers/crypto/ccp/ccp-crypto.h

146

u8 buf[AES_BLOCK_SIZE];

drivers/crypto/ccp/ccp-crypto.h

150

u8 pad[AES_BLOCK_SIZE];

drivers/crypto/ccp/ccp-crypto.h

158

u8 iv[AES_BLOCK_SIZE];

drivers/crypto/ccp/ccp-crypto.h

161

u8 buf[AES_BLOCK_SIZE];

drivers/crypto/ccp/ccp-crypto.h

177

u8 iv[AES_BLOCK_SIZE];

drivers/crypto/ccp/ccp-ops.c

1005

dm_offset = CCP_SB_BYTES - AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

1019

op.u.aes.size = AES_BLOCK_SIZE * BITS_PER_BYTE - 1;

drivers/crypto/ccp/ccp-ops.c

1033

AES_BLOCK_SIZE,

drivers/crypto/ccp/ccp-ops.c

1042

AES_BLOCK_SIZE, DMA_FROM_DEVICE);

drivers/crypto/ccp/ccp-ops.c

1049

ccp_prepare_data(&src, &dst, &op, AES_BLOCK_SIZE, true);

drivers/crypto/ccp/ccp-ops.c

1082

dm_offset = CCP_SB_BYTES - AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

1143

if (!xts->final && (xts->src_len & (AES_BLOCK_SIZE - 1)))

drivers/crypto/ccp/ccp-ops.c

1146

if (xts->iv_len != AES_BLOCK_SIZE)

drivers/crypto/ccp/ccp-ops.c

1283

dm_offset = CCP_SB_BYTES - AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

491

if (aes->src_len & (AES_BLOCK_SIZE - 1))

drivers/crypto/ccp/ccp-ops.c

494

if (aes->iv_len != AES_BLOCK_SIZE)

drivers/crypto/ccp/ccp-ops.c

501

if (aes->cmac_key_len != AES_BLOCK_SIZE)

drivers/crypto/ccp/ccp-ops.c

554

dm_offset = CCP_SB_BYTES - AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

567

AES_BLOCK_SIZE, DMA_TO_DEVICE);

drivers/crypto/ccp/ccp-ops.c

572

ccp_prepare_data(&src, NULL, &op, AES_BLOCK_SIZE, true);

drivers/crypto/ccp/ccp-ops.c

617

dm_offset = CCP_SB_BYTES - AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

674

authsize = aes->authsize ? aes->authsize : AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

760

AES_BLOCK_SIZE,

drivers/crypto/ccp/ccp-ops.c

769

ccp_prepare_data(&wa->aad, NULL, &wa->op, AES_BLOCK_SIZE, true);

drivers/crypto/ccp/ccp-ops.c

790

AES_BLOCK_SIZE,

drivers/crypto/ccp/ccp-ops.c

800

AES_BLOCK_SIZE, DMA_FROM_DEVICE);

drivers/crypto/ccp/ccp-ops.c

809

ccp_prepare_data(&wa->src, &wa->dst, &wa->op, AES_BLOCK_SIZE, true);

drivers/crypto/ccp/ccp-ops.c

811

unsigned int nbytes = ilen % AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

852

ret = ccp_init_dm_workarea(&wa->final, cmd_q, AES_BLOCK_SIZE,

drivers/crypto/ccp/ccp-ops.c

871

wa->op.src.u.dma.length = AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

874

wa->op.dst.u.dma.length = AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

943

(aes->src_len & (AES_BLOCK_SIZE - 1)))

drivers/crypto/ccp/ccp-ops.c

950

if (aes->iv_len != AES_BLOCK_SIZE)

drivers/crypto/ccree/cc_aead.c

1330

!IS_ALIGNED(cipherlen, AES_BLOCK_SIZE))

drivers/crypto/ccree/cc_aead.c

1444

req_ctx->gen_ctx.iv_dma_addr, AES_BLOCK_SIZE, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1468

AES_BLOCK_SIZE, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1482

AES_BLOCK_SIZE + req_ctx->ccm_hdr_size, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1507

AES_BLOCK_SIZE, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1553

memset(req_ctx->mac_buf, 0, AES_BLOCK_SIZE);

drivers/crypto/ccree/cc_aead.c

1554

memset(req_ctx->ccm_config, 0, AES_BLOCK_SIZE * 3);

drivers/crypto/ccree/cc_aead.c

1562

memcpy(b0, req->iv, AES_BLOCK_SIZE);

drivers/crypto/ccree/cc_aead.c

1584

memcpy(ctr_count_0, req->iv, AES_BLOCK_SIZE);

drivers/crypto/ccree/cc_aead.c

1597

memset(areq_ctx->ctr_iv, 0, AES_BLOCK_SIZE);

drivers/crypto/ccree/cc_aead.c

1634

set_din_const(&desc[idx], 0x0, AES_BLOCK_SIZE);

drivers/crypto/ccree/cc_aead.c

1635

set_dout_dlli(&desc[idx], req_ctx->hkey_dma_addr, AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

1649

AES_BLOCK_SIZE, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1679

set_din_const(&desc[idx], 0x0, AES_BLOCK_SIZE);

drivers/crypto/ccree/cc_aead.c

1716

req_ctx->gcm_iv_inc2_dma_addr, AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

1746

AES_BLOCK_SIZE, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1754

set_dout_dlli(&desc[idx], req_ctx->mac_buf_dma_addr, AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

1767

AES_BLOCK_SIZE, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1783

AES_BLOCK_SIZE, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1845

memset(req_ctx->hkey, 0, AES_BLOCK_SIZE);

drivers/crypto/ccree/cc_aead.c

1847

memset(req_ctx->mac_buf, 0, AES_BLOCK_SIZE);

drivers/crypto/ccree/cc_aead.c

1945

areq_ctx->hw_iv_size = AES_BLOCK_SIZE;

drivers/crypto/ccree/cc_aead.c

2301

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2309

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2341

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2349

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2381

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2389

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2390

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2450

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2469

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2470

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2490

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2510

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2530

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2550

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.h

17

#define CCM_CONFIG_BUF_SIZE (AES_BLOCK_SIZE * 3)

drivers/crypto/ccree/cc_aead.h

52

u8 ctr_iv[AES_BLOCK_SIZE] ____cacheline_aligned;

drivers/crypto/ccree/cc_aead.h

55

u8 gcm_iv_inc1[AES_BLOCK_SIZE] ____cacheline_aligned;

drivers/crypto/ccree/cc_aead.h

56

u8 gcm_iv_inc2[AES_BLOCK_SIZE] ____cacheline_aligned;

drivers/crypto/ccree/cc_aead.h

57

u8 hkey[AES_BLOCK_SIZE] ____cacheline_aligned;

drivers/crypto/ccree/cc_buffer_mgr.c

1009

dma_addr = dma_map_single(dev, areq_ctx->hkey, AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_buffer_mgr.c

1013

AES_BLOCK_SIZE, areq_ctx->hkey);

drivers/crypto/ccree/cc_buffer_mgr.c

1020

AES_BLOCK_SIZE, DMA_TO_DEVICE);

drivers/crypto/ccree/cc_buffer_mgr.c

1023

AES_BLOCK_SIZE, &areq_ctx->gcm_len_block);

drivers/crypto/ccree/cc_buffer_mgr.c

1030

AES_BLOCK_SIZE, DMA_TO_DEVICE);

drivers/crypto/ccree/cc_buffer_mgr.c

1034

AES_BLOCK_SIZE, (areq_ctx->gcm_iv_inc1));

drivers/crypto/ccree/cc_buffer_mgr.c

1042

AES_BLOCK_SIZE, DMA_TO_DEVICE);

drivers/crypto/ccree/cc_buffer_mgr.c

1046

AES_BLOCK_SIZE, (areq_ctx->gcm_iv_inc2));

drivers/crypto/ccree/cc_buffer_mgr.c

296

AES_BLOCK_SIZE + areq_ctx->ccm_hdr_size);

drivers/crypto/ccree/cc_buffer_mgr.c

309

(AES_BLOCK_SIZE + areq_ctx->ccm_hdr_size),

drivers/crypto/ccree/cc_buffer_mgr.c

472

AES_BLOCK_SIZE, DMA_BIDIRECTIONAL);

drivers/crypto/ccree/cc_buffer_mgr.c

477

AES_BLOCK_SIZE, DMA_TO_DEVICE);

drivers/crypto/ccree/cc_buffer_mgr.c

482

AES_BLOCK_SIZE, DMA_TO_DEVICE);

drivers/crypto/ccree/cc_buffer_mgr.c

487

AES_BLOCK_SIZE, DMA_TO_DEVICE);

drivers/crypto/ccree/cc_buffer_mgr.c

494

AES_BLOCK_SIZE, DMA_TO_DEVICE);

drivers/crypto/ccree/cc_buffer_mgr.c

990

dma_addr = dma_map_single(dev, addr, AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_buffer_mgr.c

995

AES_BLOCK_SIZE, addr);

drivers/crypto/ccree/cc_cipher.c

1014

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1025

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1032

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1043

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1061

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1068

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1079

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1086

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1104

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1126

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1136

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1143

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

115

if (size >= AES_BLOCK_SIZE)

drivers/crypto/ccree/cc_cipher.c

1153

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1170

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1177

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1187

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1194

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1211

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

124

if (IS_ALIGNED(size, AES_BLOCK_SIZE))

drivers/crypto/ccree/cc_hash.c

1772

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_hash.c

1784

.digestsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_hash.c

1785

.statesize = CC_STATE_SIZE(AES_BLOCK_SIZE),

drivers/crypto/ccree/cc_hash.c

1790

.inter_digestsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_hash.c

1797

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_hash.c

1809

.digestsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_hash.c

1810

.statesize = CC_STATE_SIZE(AES_BLOCK_SIZE),

drivers/crypto/ccree/cc_hash.c

1815

.inter_digestsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_hash.h

31

u8 state[AES_BLOCK_SIZE];

drivers/crypto/ccree/cc_hash.h

33

u8 buffer[AES_BLOCK_SIZE];

drivers/crypto/chelsio/chcr_algo.c

1000

memcpy(dstiv, srciv, AES_BLOCK_SIZE);

drivers/crypto/chelsio/chcr_algo.c

1014

__be32 *b = (__be32 *)(iv + AES_BLOCK_SIZE);

drivers/crypto/chelsio/chcr_algo.c

1020

if ((bytes / AES_BLOCK_SIZE) >= c)

drivers/crypto/chelsio/chcr_algo.c

1021

bytes = c * AES_BLOCK_SIZE;

drivers/crypto/chelsio/chcr_algo.c

1035

int round = reqctx->last_req_len / AES_BLOCK_SIZE;

drivers/crypto/chelsio/chcr_algo.c

1038

memcpy(iv, reqctx->iv, AES_BLOCK_SIZE);

drivers/crypto/chelsio/chcr_algo.c

1076

AES_BLOCK_SIZE));

drivers/crypto/chelsio/chcr_algo.c

1080

AES_BLOCK_SIZE) + 1);

drivers/crypto/chelsio/chcr_algo.c

1086

memcpy(iv, req->iv, AES_BLOCK_SIZE);

drivers/crypto/chelsio/chcr_algo.c

1088

memcpy(iv, &fw6_pld->data[2], AES_BLOCK_SIZE);

drivers/crypto/chelsio/chcr_algo.c

1110

AES_BLOCK_SIZE));

drivers/crypto/chelsio/chcr_algo.c

1113

memcpy(iv, reqctx->iv, AES_BLOCK_SIZE);

drivers/crypto/chelsio/chcr_algo.c

1120

memcpy(iv, &fw6_pld->data[2], AES_BLOCK_SIZE);

drivers/crypto/chelsio/chcr_algo.c

1232

if ((ablkctx->enckey_len == 0) || (ivsize > AES_BLOCK_SIZE) ||

drivers/crypto/chelsio/chcr_algo.c

3729

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

3735

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

3747

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

3753

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

3771

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

3971

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

4004

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

4011

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

4026

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

4033

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

4047

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

4053

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

4067

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

4074

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

4088

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

4095

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

4109

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

4116

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/chelsio/chcr_algo.c

73

#define IV AES_BLOCK_SIZE

drivers/crypto/chelsio/chcr_algo.c

862

reqctx->processed + wrparam->bytes - AES_BLOCK_SIZE);

drivers/crypto/chelsio/chcr_algo.c

996

unsigned int size = AES_BLOCK_SIZE;

drivers/crypto/chelsio/chcr_algo.h

116

sizeof(struct cpl_rx_phys_dsgl) + AES_BLOCK_SIZE)

drivers/crypto/gemini/sl3516-ce-core.c

227

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/geode-aes.c

173

geode_aes_crypt(tctx, in, out, AES_BLOCK_SIZE, NULL,

drivers/crypto/geode-aes.c

188

geode_aes_crypt(tctx, in, out, AES_BLOCK_SIZE, NULL,

drivers/crypto/geode-aes.c

224

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/geode-aes.c

286

round_down(nbytes, AES_BLOCK_SIZE),

drivers/crypto/geode-aes.c

288

err = skcipher_walk_done(&walk, nbytes % AES_BLOCK_SIZE);

drivers/crypto/geode-aes.c

321

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/geode-aes.c

332

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/geode-aes.c

339

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/hisilicon/sec/sec_algs.c

1011

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/hisilicon/sec/sec_algs.c

939

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/hisilicon/sec/sec_algs.c

959

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/hisilicon/sec/sec_algs.c

971

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/hisilicon/sec/sec_algs.c

979

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/hisilicon/sec/sec_algs.c

991

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/hisilicon/sec/sec_algs.c

999

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/hisilicon/sec2/sec_crypto.c

2237

if (unlikely(cryptlen < AES_BLOCK_SIZE)) {

drivers/crypto/hisilicon/sec2/sec_crypto.c

2244

if (unlikely(cryptlen & (AES_BLOCK_SIZE - 1))) {

drivers/crypto/hisilicon/sec2/sec_crypto.c

2398

AES_MAX_KEY_SIZE, AES_BLOCK_SIZE, 0),

drivers/crypto/hisilicon/sec2/sec_crypto.c

2403

AES_MAX_KEY_SIZE, AES_BLOCK_SIZE, AES_BLOCK_SIZE),

drivers/crypto/hisilicon/sec2/sec_crypto.c

2408

AES_MAX_KEY_SIZE, SEC_MIN_BLOCK_SZ, AES_BLOCK_SIZE),

drivers/crypto/hisilicon/sec2/sec_crypto.c

2413

SEC_XTS_MAX_KEY_SIZE, AES_BLOCK_SIZE, AES_BLOCK_SIZE),

drivers/crypto/hisilicon/sec2/sec_crypto.c

2418

AES_MIN_KEY_SIZE, AES_BLOCK_SIZE, AES_BLOCK_SIZE),

drivers/crypto/hisilicon/sec2/sec_crypto.c

2423

AES_MIN_KEY_SIZE, SEC_MIN_BLOCK_SZ, AES_BLOCK_SIZE),

drivers/crypto/hisilicon/sec2/sec_crypto.c

2428

SEC_XTS_MIN_KEY_SIZE, AES_BLOCK_SIZE, AES_BLOCK_SIZE),

drivers/crypto/hisilicon/sec2/sec_crypto.c

2504

sreq->c_req.c_len & (AES_BLOCK_SIZE - 1))) {

drivers/crypto/hisilicon/sec2/sec_crypto.c

2626

sec_aead_xcm_ctx_exit, SEC_MIN_BLOCK_SZ, AES_BLOCK_SIZE,

drivers/crypto/hisilicon/sec2/sec_crypto.c

2627

AES_BLOCK_SIZE),

drivers/crypto/hisilicon/sec2/sec_crypto.c

2633

AES_BLOCK_SIZE),

drivers/crypto/hisilicon/sec2/sec_crypto.c

2638

sec_aead_xcm_ctx_exit, SEC_MIN_BLOCK_SZ, AES_BLOCK_SIZE,

drivers/crypto/hisilicon/sec2/sec_crypto.c

2639

AES_BLOCK_SIZE),

drivers/crypto/hisilicon/sec2/sec_crypto.c

2645

AES_BLOCK_SIZE),

drivers/crypto/hisilicon/sec2/sec_crypto.c

2650

sec_aead_sha1_ctx_init, sec_aead_ctx_exit, AES_BLOCK_SIZE,

drivers/crypto/hisilicon/sec2/sec_crypto.c

2651

AES_BLOCK_SIZE, SHA1_DIGEST_SIZE),

drivers/crypto/hisilicon/sec2/sec_crypto.c

2656

sec_aead_sha256_ctx_init, sec_aead_ctx_exit, AES_BLOCK_SIZE,

drivers/crypto/hisilicon/sec2/sec_crypto.c

2657

AES_BLOCK_SIZE, SHA256_DIGEST_SIZE),

drivers/crypto/hisilicon/sec2/sec_crypto.c

2662

sec_aead_sha512_ctx_init, sec_aead_ctx_exit, AES_BLOCK_SIZE,

drivers/crypto/hisilicon/sec2/sec_crypto.c

2663

AES_BLOCK_SIZE, SHA512_DIGEST_SIZE),

drivers/crypto/inside-secure/eip93/eip93-aead.c

268

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/eip93/eip93-aead.c

279

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/eip93/eip93-aead.c

296

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/eip93/eip93-aead.c

307

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/eip93/eip93-aead.c

324

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/eip93/eip93-aead.c

335

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/eip93/eip93-aead.c

352

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/eip93/eip93-aead.c

363

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/eip93/eip93-cipher.c

121

ctx->blksize = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/eip93/eip93-cipher.c

220

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/eip93/eip93-cipher.c

239

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/eip93/eip93-cipher.c

247

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/eip93/eip93-cipher.c

266

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/eip93/eip93-common.c

525

u32 iv[AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/inside-secure/eip93/eip93-common.c

550

blocks = DIV_ROUND_UP(rctx->textsize, AES_BLOCK_SIZE);

drivers/crypto/inside-secure/eip93/eip93-common.c

556

split = AES_BLOCK_SIZE * -start;

drivers/crypto/inside-secure/eip93/eip93-common.c

562

crypto_inc((u8 *)iv, AES_BLOCK_SIZE);

drivers/crypto/inside-secure/safexcel_cipher.c

1054

u8 input_iv[AES_BLOCK_SIZE];

drivers/crypto/inside-secure/safexcel_cipher.c

1307

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1323

ctx->blocksz = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_cipher.c

1337

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1345

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1397

ctx->blocksz = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_cipher.c

1655

ctx->blocksz = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_cipher.c

1682

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1691

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1718

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1727

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1754

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1763

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1790

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1799

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1826

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1835

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

213

atoken->packet_length = AES_BLOCK_SIZE +

drivers/crypto/inside-secure/safexcel_cipher.c

2454

ctx->blocksz = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_cipher.c

2511

u32 hashkey[AES_BLOCK_SIZE >> 2];

drivers/crypto/inside-secure/safexcel_cipher.c

2533

memset(hashkey, 0, AES_BLOCK_SIZE);

drivers/crypto/inside-secure/safexcel_cipher.c

2537

for (i = 0; i < AES_BLOCK_SIZE / sizeof(u32); i++) {

drivers/crypto/inside-secure/safexcel_cipher.c

2545

for (i = 0; i < AES_BLOCK_SIZE / sizeof(u32); i++)

drivers/crypto/inside-secure/safexcel_cipher.c

2548

memzero_explicit(hashkey, AES_BLOCK_SIZE);

drivers/crypto/inside-secure/safexcel_cipher.c

2630

ctx->base.ipad.be[i + 2 * AES_BLOCK_SIZE / sizeof(u32)] =

drivers/crypto/inside-secure/safexcel_cipher.c

2635

ctx->state_sz = 2 * AES_BLOCK_SIZE + len;

drivers/crypto/inside-secure/safexcel_cipher.c

2654

ctx->state_sz = 3 * AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_cipher.c

2709

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

2710

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

288

atoken->instructions = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_cipher.c

292

atoken->packet_length = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_cipher.c

3593

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_hash.c

1892

req->len = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_hash.c

1893

req->processed = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_hash.c

1897

req->digest_sz = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_hash.c

1898

req->block_sz = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_hash.c

1915

memset(&ctx->base.ipad, 0, 2 * AES_BLOCK_SIZE);

drivers/crypto/inside-secure/safexcel_hash.c

1921

ctx->key_sz = AES_MAX_KEY_SIZE + 2 * AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_hash.c

1924

ctx->key_sz = AES_MAX_KEY_SIZE + 2 * AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_hash.c

1927

ctx->key_sz = AES_MIN_KEY_SIZE + 2 * AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_hash.c

1953

.digestsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_hash.c

1962

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_hash.c

1976

u32 key_tmp[3 * AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/inside-secure/safexcel_hash.c

1984

aes_encrypt(ctx->aes, (u8 *)key_tmp + 2 * AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_hash.c

1988

aes_encrypt(ctx->aes, (u8 *)key_tmp + AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_hash.c

1990

for (i = 0; i < 3 * AES_BLOCK_SIZE / sizeof(u32); i++)

drivers/crypto/inside-secure/safexcel_hash.c

1994

(u8 *)key_tmp + 2 * AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_hash.c

2000

ctx->key_sz = AES_MIN_KEY_SIZE + 2 * AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_hash.c

2036

.digestsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_hash.c

2045

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_hash.c

2074

memset(consts, 0, AES_BLOCK_SIZE);

drivers/crypto/inside-secure/safexcel_hash.c

2092

for (i = 0; i < 2 * AES_BLOCK_SIZE / sizeof(u32); i++)

drivers/crypto/inside-secure/safexcel_hash.c

2097

ctx->key_sz = AES_MAX_KEY_SIZE + 2 * AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_hash.c

2100

ctx->key_sz = AES_MAX_KEY_SIZE + 2 * AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_hash.c

2103

ctx->key_sz = AES_MIN_KEY_SIZE + 2 * AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_hash.c

2123

.digestsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_hash.c

2132

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_hash.c

354

if (unlikely(req->xcbcmac && req->processed > AES_BLOCK_SIZE)) {

drivers/crypto/inside-secure/safexcel_hash.c

355

if (unlikely(cache_len < AES_BLOCK_SIZE)) {

drivers/crypto/inside-secure/safexcel_hash.c

359

extra = AES_BLOCK_SIZE - cache_len;

drivers/crypto/inside-secure/safexcel_hash.c

376

for (i = 0; i < AES_BLOCK_SIZE / 4; i++) {

drivers/crypto/inside-secure/safexcel_hash.c

385

cache_len = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_hash.c

390

crypto_xor(req->cache, (const u8 *)req->state, AES_BLOCK_SIZE);

drivers/crypto/inside-secure/safexcel_hash.c

808

} else if (unlikely(ctx->cbcmac && req->len == AES_BLOCK_SIZE &&

drivers/crypto/inside-secure/safexcel_hash.c

811

memset(areq->result, 0, AES_BLOCK_SIZE);

drivers/crypto/inside-secure/safexcel_hash.c

813

} else if (unlikely(req->xcbcmac && req->len == AES_BLOCK_SIZE &&

drivers/crypto/inside-secure/safexcel_hash.c

818

for (i = 0; i < AES_BLOCK_SIZE / sizeof(u32); i++) {

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1363

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1367

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1374

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1388

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1399

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1463

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1465

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1475

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1477

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

102

u8 in_tag[AES_BLOCK_SIZE];

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

105

u8 out_tag[AES_BLOCK_SIZE];

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1267

.base.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1289

.base.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1296

.base.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1318

.base.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1334

.base.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1341

.base.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1357

.base.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1378

.base.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1385

.base.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1406

.base.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1421

.base.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1428

.base.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1456

.base.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1478

.base.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1479

.base.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1501

.base.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1522

.base.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

1523

.base.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

227

u8 tmp_buf1[AES_BLOCK_SIZE], tmp_buf2[AES_BLOCK_SIZE];

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

233

sg_pcopy_to_buffer(sgl, nents, tmp_buf1, AES_BLOCK_SIZE, blk1_offset);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

234

sg_pcopy_to_buffer(sgl, nents, tmp_buf2, AES_BLOCK_SIZE, blk2_offset);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

235

sg_pcopy_from_buffer(sgl, nents, tmp_buf1, AES_BLOCK_SIZE, blk2_offset);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

236

sg_pcopy_from_buffer(sgl, nents, tmp_buf2, AES_BLOCK_SIZE, blk1_offset);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

261

if (req->cryptlen % AES_BLOCK_SIZE != 0)

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

268

if (req->cryptlen % AES_BLOCK_SIZE != 0)

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

272

if (!req->iv || iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

283

if (!req->iv || iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

289

if (req->cryptlen < AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

293

if (!req->iv || iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

420

req->cryptlen - AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

421

req->cryptlen - (2 * AES_BLOCK_SIZE));

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

536

req->cryptlen > AES_BLOCK_SIZE &&

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

537

req->cryptlen % AES_BLOCK_SIZE == 0);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

561

req->cryptlen - AES_BLOCK_SIZE,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

562

req->cryptlen - (2 * AES_BLOCK_SIZE));

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

619

if (iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

94

u8 last_ct_blk[AES_BLOCK_SIZE];

drivers/crypto/intel/keembay/ocs-aes.c

1325

AES_BLOCK_SIZE, adata_dma_list, adata_size,

drivers/crypto/intel/keembay/ocs-aes.c

589

val = size % AES_BLOCK_SIZE;

drivers/crypto/intel/keembay/ocs-aes.c

591

val = AES_BLOCK_SIZE;

drivers/crypto/intel/keembay/ocs-aes.c

644

if (src_size % AES_BLOCK_SIZE != 0)

drivers/crypto/intel/keembay/ocs-aes.c

656

if (src_size % AES_BLOCK_SIZE != 0)

drivers/crypto/intel/keembay/ocs-aes.c

665

if (!iv || iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/ocs-aes.c

681

if (!iv || iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/ocs-aes.c

688

if (src_size < AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/ocs-aes.c

697

if (!iv || iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/keembay/ocs-aes.c

731

if (!iv || iv_size != AES_BLOCK_SIZE)

drivers/crypto/intel/qat/qat_common/qat_algs.c

1052

if (req->cryptlen % AES_BLOCK_SIZE != 0)

drivers/crypto/intel/qat/qat_common/qat_algs.c

1207

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/qat/qat_common/qat_algs.c

1216

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/qat/qat_common/qat_algs.c

1224

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/qat/qat_common/qat_algs.c

1233

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/qat/qat_common/qat_algs.c

1241

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/qat/qat_common/qat_algs.c

1250

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/qat/qat_common/qat_algs.c

1259

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/qat/qat_common/qat_algs.c

1271

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/qat/qat_common/qat_algs.c

1289

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/qat/qat_common/qat_algs.c

1296

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/qat/qat_common/qat_algs.c

1308

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/qat/qat_common/qat_algs.c

205

cipher_cd_ctrl->cipher_state_sz = AES_BLOCK_SIZE >> 3;

drivers/crypto/intel/qat/qat_common/qat_algs.c

292

cipher_cd_ctrl->cipher_state_sz = AES_BLOCK_SIZE >> 3;

drivers/crypto/intel/qat/qat_common/qat_algs.c

369

cd_ctrl->cipher_state_sz = AES_BLOCK_SIZE >> 3;

drivers/crypto/intel/qat/qat_common/qat_algs.c

398

key = (u8 *)aes_expanded.key_enc + (AES_BLOCK_SIZE * nrounds);

drivers/crypto/intel/qat/qat_common/qat_algs.c

399

memcpy(key_reverse, key, AES_BLOCK_SIZE);

drivers/crypto/intel/qat/qat_common/qat_algs.c

403

key = (u8 *)aes_expanded.key_enc + (AES_BLOCK_SIZE * nrounds);

drivers/crypto/intel/qat/qat_common/qat_algs.c

404

memcpy(key_reverse, key, AES_BLOCK_SIZE);

drivers/crypto/intel/qat/qat_common/qat_algs.c

405

memcpy(key_reverse + AES_BLOCK_SIZE, key - AES_BLOCK_SIZE,

drivers/crypto/intel/qat/qat_common/qat_algs.c

406

AES_BLOCK_SIZE);

drivers/crypto/intel/qat/qat_common/qat_algs.c

612

memcpy(qat_req->iv, sreq->iv, AES_BLOCK_SIZE);

drivers/crypto/intel/qat/qat_common/qat_algs.c

618

iv_lo += DIV_ROUND_UP(sreq->cryptlen, AES_BLOCK_SIZE);

drivers/crypto/intel/qat/qat_common/qat_algs.c

629

int offset = sreq->cryptlen - AES_BLOCK_SIZE;

drivers/crypto/intel/qat/qat_common/qat_algs.c

637

scatterwalk_map_and_copy(qat_req->iv, sgl, offset, AES_BLOCK_SIZE, 0);

drivers/crypto/intel/qat/qat_common/qat_algs.c

676

memcpy(sreq->iv, qat_req->iv, AES_BLOCK_SIZE);

drivers/crypto/intel/qat/qat_common/qat_algs.c

722

if (cipher_len % AES_BLOCK_SIZE != 0)

drivers/crypto/intel/qat/qat_common/qat_algs.c

741

memcpy(cipher_param->u.cipher_IV_array, areq->iv, AES_BLOCK_SIZE);

drivers/crypto/intel/qat/qat_common/qat_algs.c

766

if (areq->cryptlen % AES_BLOCK_SIZE != 0)

drivers/crypto/intel/qat/qat_common/qat_algs.c

785

memcpy(cipher_param->u.cipher_IV_array, iv, AES_BLOCK_SIZE);

drivers/crypto/intel/qat/qat_common/qat_algs.c

938

memcpy(cipher_param->u.cipher_IV_array, iv, AES_BLOCK_SIZE);

drivers/crypto/intel/qat/qat_common/qat_algs.c

984

if (req->cryptlen % AES_BLOCK_SIZE != 0)

drivers/crypto/intel/qat/qat_common/qat_crypto.h

47

u8 iv[AES_BLOCK_SIZE];

drivers/crypto/marvell/cesa/cipher.c

765

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/cesa/cipher.c

779

memcpy(tmpl->ctx.skcipher.iv, req->iv, AES_BLOCK_SIZE);

drivers/crypto/marvell/cesa/cipher.c

808

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/marvell/cesa/cipher.c

815

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1226

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1233

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1243

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1250

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1260

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1313

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1326

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1332

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1345

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1351

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1364

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1370

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1383

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1327

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1335

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1345

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1353

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1363

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1419

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1432

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1438

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1451

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1457

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1470

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1476

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1489

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/mxs-dcp.c

257

if (actx->fill % AES_BLOCK_SIZE) {

drivers/crypto/mxs-dcp.c

400

memcpy(req->iv, out_buf+(last_out_len-AES_BLOCK_SIZE),

drivers/crypto/mxs-dcp.c

401

AES_BLOCK_SIZE);

drivers/crypto/mxs-dcp.c

403

memcpy(req->iv, in_buf+(last_out_len-AES_BLOCK_SIZE),

drivers/crypto/mxs-dcp.c

404

AES_BLOCK_SIZE);

drivers/crypto/mxs-dcp.c

916

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/mxs-dcp.c

934

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/mxs-dcp.c

943

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/mxs-dcp.c

952

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/mxs-dcp.c

968

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/mxs-dcp.c

977

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/nx/nx-aes-cbc.c

117

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/nx/nx-aes-cbc.c

125

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/nx/nx-aes-cbc.c

91

memcpy(req->iv, csbcpb->cpb.aes_cbc.cv, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-ccm.c

306

AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-ccm.c

319

memcpy(out, result, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-ccm.c

378

memcpy(iv, csbcpb->cpb.aes_ccm.out_ctr, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-ccm.c

380

csbcpb->cpb.aes_ccm.out_pat_or_mac, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-ccm.c

382

csbcpb->cpb.aes_ccm.out_s0, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-ccm.c

447

memcpy(iv, csbcpb->cpb.aes_ccm.out_ctr, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-ccm.c

449

csbcpb->cpb.aes_ccm.out_pat_or_mac, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-ccm.c

451

csbcpb->cpb.aes_ccm.out_s0, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-ccm.c

533

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/nx/nx-aes-ccm.c

534

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/nx/nx-aes-ccm.c

554

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/nx/nx-aes-ctr.c

104

memcpy(iv, csbcpb->cpb.aes_cbc.cv, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-ctr.c

146

.chunksize = AES_BLOCK_SIZE,

drivers/crypto/nx/nx-aes-ecb.c

116

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/nx/nx-aes-gcm.c

111

if (nbytes <= AES_BLOCK_SIZE) {

drivers/crypto/nx/nx-aes-gcm.c

152

AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-gcm.c

161

memcpy(out, csbcpb_aead->cpb.aes_gca.out_pat, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-gcm.c

189

memcpy(csbcpb->cpb.aes_gcm.iv_or_cnt, iv, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-gcm.c

221

csbcpb->cpb.aes_gcm.out_pat_or_mac, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-gcm.c

223

csbcpb->cpb.aes_gcm.out_s0, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-gcm.c

245

char out[AES_BLOCK_SIZE];

drivers/crypto/nx/nx-aes-gcm.c

263

len = AES_BLOCK_SIZE;

drivers/crypto/nx/nx-aes-gcm.c

269

if (len != AES_BLOCK_SIZE)

drivers/crypto/nx/nx-aes-gcm.c

373

memcpy(rctx->iv, csbcpb->cpb.aes_gcm.out_cnt, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-gcm.c

375

csbcpb->cpb.aes_gcm.out_pat_or_mac, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-gcm.c

377

csbcpb->cpb.aes_gcm.out_s0, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-gcm.c

477

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/nx/nx-aes-gcm.c

495

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/nx/nx-aes-xcbc.c

106

memcpy(csbcpb->cpb.aes_ecb.key, keys[0], AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-xcbc.c

113

len = AES_BLOCK_SIZE;

drivers/crypto/nx/nx-aes-xcbc.c

117

if (len != AES_BLOCK_SIZE)

drivers/crypto/nx/nx-aes-xcbc.c

131

memcpy(csbcpb->cpb.aes_xcbc.key, key, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-xcbc.c

181

memcpy(csbcpb->cpb.aes_xcbc.out_cv_mac, sctx->state, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-xcbc.c

193

data_len = AES_BLOCK_SIZE;

drivers/crypto/nx/nx-aes-xcbc.c

197

if (data_len != AES_BLOCK_SIZE) {

drivers/crypto/nx/nx-aes-xcbc.c

205

to_process = total & ~(AES_BLOCK_SIZE - 1);

drivers/crypto/nx/nx-aes-xcbc.c

218

csbcpb->cpb.aes_xcbc.out_cv_mac, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-xcbc.c

234

} while (total >= AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-xcbc.c

237

memcpy(sctx->state, csbcpb->cpb.aes_xcbc.out_cv_mac, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-xcbc.c

24

u8 state[AES_BLOCK_SIZE];

drivers/crypto/nx/nx-aes-xcbc.c

259

memcpy(csbcpb->cpb.aes_xcbc.cv, sctx->state, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-xcbc.c

283

len = AES_BLOCK_SIZE;

drivers/crypto/nx/nx-aes-xcbc.c

287

if (len != AES_BLOCK_SIZE) {

drivers/crypto/nx/nx-aes-xcbc.c

306

memcpy(out, csbcpb->cpb.aes_xcbc.out_cv_mac, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-xcbc.c

313

.digestsize = AES_BLOCK_SIZE,

drivers/crypto/nx/nx-aes-xcbc.c

327

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/nx/nx-aes-xcbc.c

63

u8 keys[2][AES_BLOCK_SIZE];

drivers/crypto/nx/nx-aes-xcbc.c

70

memcpy(key, csbcpb->cpb.aes_xcbc.key, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-aes-xcbc.c

71

memcpy(csbcpb->cpb.aes_ecb.key, key, AES_BLOCK_SIZE);

drivers/crypto/nx/nx.c

210

data_back = (abs(oplen) / AES_BLOCK_SIZE) * sg->len;

drivers/crypto/nx/nx.c

211

data_back = *nbytes - (data_back & ~(AES_BLOCK_SIZE - 1));

drivers/crypto/nx/nx.c

255

memcpy(oiv, iv, AES_BLOCK_SIZE);

drivers/crypto/nx/nx.c

265

delta = *nbytes - (*nbytes & ~(AES_BLOCK_SIZE - 1));

drivers/crypto/omap-aes-gcm.c

109

alen = ALIGN(assoclen, AES_BLOCK_SIZE);

drivers/crypto/omap-aes-gcm.c

110

clen = ALIGN(cryptlen, AES_BLOCK_SIZE);

drivers/crypto/omap-aes-gcm.c

120

AES_BLOCK_SIZE, dd->in_sgl,

drivers/crypto/omap-aes-gcm.c

137

AES_BLOCK_SIZE, &dd->in_sgl[nsg],

drivers/crypto/omap-aes-gcm.c

163

AES_BLOCK_SIZE, &dd->out_sgl,

drivers/crypto/omap-aes-gcm.c

50

alen = ALIGN(dd->assoc_len, AES_BLOCK_SIZE);

drivers/crypto/omap-aes-gcm.c

51

clen = ALIGN(dd->total, AES_BLOCK_SIZE);

drivers/crypto/omap-aes.c

448

ret = omap_crypto_align_sg(&dd->in_sg, dd->total, AES_BLOCK_SIZE,

drivers/crypto/omap-aes.c

454

ret = omap_crypto_align_sg(&dd->out_sg, dd->total, AES_BLOCK_SIZE,

drivers/crypto/omap-aes.c

537

if ((req->cryptlen % AES_BLOCK_SIZE) && !(mode & FLAGS_CTR))

drivers/crypto/omap-aes.c

665

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/omap-aes.c

687

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/omap-aes.c

693

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/omap-aes.c

719

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/omap-aes.c

753

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/omap-aes.c

775

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/omap-aes.c

922

dd->total -= min_t(size_t, AES_BLOCK_SIZE, dd->total);

drivers/crypto/omap-aes.h

107

u8 iv[AES_BLOCK_SIZE];

drivers/crypto/omap-aes.h

108

u32 auth_tag[AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/omap-aes.h

85

#define AES_BLOCK_WORDS (AES_BLOCK_SIZE >> 2)

drivers/crypto/padlock-aes.c

218

u8 buf[AES_BLOCK_SIZE * (MAX_ECB_FETCH_BLOCKS - 1) + PADLOCK_ALIGNMENT - 1];

drivers/crypto/padlock-aes.c

221

memcpy(tmp, in, count * AES_BLOCK_SIZE);

drivers/crypto/padlock-aes.c

232

u8 buf[AES_BLOCK_SIZE * (MAX_CBC_FETCH_BLOCKS - 1) + PADLOCK_ALIGNMENT - 1];

drivers/crypto/padlock-aes.c

235

memcpy(tmp, in, count * AES_BLOCK_SIZE);

drivers/crypto/padlock-aes.c

329

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/padlock-aes.c

359

nbytes / AES_BLOCK_SIZE);

drivers/crypto/padlock-aes.c

36

#define ecb_fetch_bytes (ecb_fetch_blocks * AES_BLOCK_SIZE)

drivers/crypto/padlock-aes.c

360

nbytes &= AES_BLOCK_SIZE - 1;

drivers/crypto/padlock-aes.c

384

nbytes / AES_BLOCK_SIZE);

drivers/crypto/padlock-aes.c

385

nbytes &= AES_BLOCK_SIZE - 1;

drivers/crypto/padlock-aes.c

398

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/padlock-aes.c

40

#define cbc_fetch_bytes (cbc_fetch_blocks * AES_BLOCK_SIZE)

drivers/crypto/padlock-aes.c

425

nbytes / AES_BLOCK_SIZE);

drivers/crypto/padlock-aes.c

426

memcpy(walk.iv, iv, AES_BLOCK_SIZE);

drivers/crypto/padlock-aes.c

427

nbytes &= AES_BLOCK_SIZE - 1;

drivers/crypto/padlock-aes.c

451

nbytes / AES_BLOCK_SIZE);

drivers/crypto/padlock-aes.c

452

nbytes &= AES_BLOCK_SIZE - 1;

drivers/crypto/padlock-aes.c

465

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/padlock-aes.c

471

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/qce/aead.c

426

rctx->ivsize = AES_BLOCK_SIZE;

drivers/crypto/qce/aead.c

737

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/qce/aead.c

738

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/qce/aead.c

746

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/qce/aead.c

747

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/qce/aead.c

755

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/qce/common.h

24

#define QCE_AES_IV_LENGTH AES_BLOCK_SIZE

drivers/crypto/qce/common.h

26

#define QCE_MAX_IV_SIZE AES_BLOCK_SIZE

drivers/crypto/qce/skcipher.c

365

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/qce/skcipher.c

374

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/qce/skcipher.c

375

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/qce/skcipher.c

384

.chunksize = AES_BLOCK_SIZE,

drivers/crypto/qce/skcipher.c

385

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/qce/skcipher.c

393

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/qce/skcipher.c

394

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/rockchip/rk3288_crypto.h

247

u8 iv[AES_BLOCK_SIZE];

drivers/crypto/rockchip/rk3288_crypto.h

253

u8 backup_iv[AES_BLOCK_SIZE];

drivers/crypto/rockchip/rk3288_crypto_skcipher.c

308

u8 iv[AES_BLOCK_SIZE];

drivers/crypto/rockchip/rk3288_crypto_skcipher.c

309

u8 biv[AES_BLOCK_SIZE];

drivers/crypto/rockchip/rk3288_crypto_skcipher.c

468

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/rockchip/rk3288_crypto_skcipher.c

493

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/rockchip/rk3288_crypto_skcipher.c

502

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/s5p-sss.c

1792

AES_BLOCK_SIZE);

drivers/crypto/s5p-sss.c

1796

AES_BLOCK_SIZE);

drivers/crypto/s5p-sss.c

1811

if (!IS_ALIGNED(sg->length, AES_BLOCK_SIZE))

drivers/crypto/s5p-sss.c

2009

if (!IS_ALIGNED(req->cryptlen, AES_BLOCK_SIZE) &&

drivers/crypto/s5p-sss.c

2079

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/s5p-sss.c

2097

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/s5p-sss.c

2104

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/s5p-sss.c

2123

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/s5p-sss.c

452

len = ALIGN(dev->req->cryptlen, AES_BLOCK_SIZE);

drivers/crypto/s5p-sss.c

474

memcpy_fromio(req->iv, dev->aes_ioaddr + SSS_REG_AES_IV_DATA(0), AES_BLOCK_SIZE);

drivers/crypto/s5p-sss.c

477

memcpy_fromio(req->iv, dev->aes_ioaddr + SSS_REG_AES_CNT_DATA(0), AES_BLOCK_SIZE);

drivers/crypto/s5p-sss.c

506

len = ALIGN(dev->req->cryptlen, AES_BLOCK_SIZE);

drivers/crypto/sa2ul.c

1951

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/sa2ul.c

1958

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/sa2ul.c

1974

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/sa2ul.c

2125

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/sa2ul.c

2134

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/sa2ul.c

2152

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/sa2ul.c

2162

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/sahara.c

1105

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/sahara.c

1127

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/sahara.c

1136

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/sahara.c

148

u8 iv_out[AES_BLOCK_SIZE];

drivers/crypto/sahara.c

444

dev->hw_desc[idx]->len1 = AES_BLOCK_SIZE;

drivers/crypto/sahara.c

680

if (!IS_ALIGNED(req->cryptlen, AES_BLOCK_SIZE))

drivers/crypto/starfive/jh7110-aes.c

1029

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/starfive/jh7110-aes.c

1045

.base.ivsize = AES_BLOCK_SIZE,

drivers/crypto/starfive/jh7110-aes.c

1052

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/starfive/jh7110-aes.c

1068

.base.ivsize = AES_BLOCK_SIZE,

drivers/crypto/starfive/jh7110-aes.c

1095

.base.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/starfive/jh7110-aes.c

1117

.base.ivsize = AES_BLOCK_SIZE,

drivers/crypto/starfive/jh7110-aes.c

1118

.base.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/starfive/jh7110-aes.c

200

u8 iv[AES_BLOCK_SIZE], b0[AES_BLOCK_SIZE];

drivers/crypto/starfive/jh7110-aes.c

203

memcpy(iv, cryp->req.areq->iv, AES_BLOCK_SIZE);

drivers/crypto/starfive/jh7110-aes.c

204

memset(iv + AES_BLOCK_SIZE - 1 - iv[0], 0, iv[0] + 1);

drivers/crypto/starfive/jh7110-aes.c

207

memcpy(b0, iv, AES_BLOCK_SIZE);

drivers/crypto/starfive/jh7110-aes.c

216

b0[AES_BLOCK_SIZE - 2] = textlen >> 8;

drivers/crypto/starfive/jh7110-aes.c

217

b0[AES_BLOCK_SIZE - 1] = textlen & 0xFF;

drivers/crypto/starfive/jh7110-aes.c

349

total_len = ALIGN(cryp->assoclen, AES_BLOCK_SIZE) / sizeof(unsigned int);

drivers/crypto/starfive/jh7110-aes.c

397

total_len -= AES_BLOCK_SIZE;

drivers/crypto/starfive/jh7110-aes.c

454

writel(ALIGN(len, AES_BLOCK_SIZE), cryp->base + STARFIVE_DMA_IN_LEN_OFFSET);

drivers/crypto/starfive/jh7110-aes.c

455

writel(ALIGN(len, AES_BLOCK_SIZE), cryp->base + STARFIVE_DMA_OUT_LEN_OFFSET);

drivers/crypto/starfive/jh7110-aes.c

457

sg_dma_len(src) = ALIGN(len, AES_BLOCK_SIZE);

drivers/crypto/starfive/jh7110-aes.c

458

sg_dma_len(dst) = ALIGN(len, AES_BLOCK_SIZE);

drivers/crypto/starfive/jh7110-aes.c

50

#define AES_BLOCK_32 (AES_BLOCK_SIZE / sizeof(u32))

drivers/crypto/starfive/jh7110-aes.c

667

rctx->adata = kzalloc(cryp->assoclen + AES_BLOCK_SIZE, GFP_KERNEL);

drivers/crypto/starfive/jh7110-aes.c

758

(!IS_ALIGNED(tsg->length, AES_BLOCK_SIZE) &&

drivers/crypto/starfive/jh7110-aes.c

765

(!IS_ALIGNED(tsg->length, AES_BLOCK_SIZE) &&

drivers/crypto/starfive/jh7110-cryp.h

31

#define STARFIVE_AES_IV_LEN AES_BLOCK_SIZE

drivers/crypto/starfive/jh7110-cryp.h

32

#define STARFIVE_AES_CTR_LEN AES_BLOCK_SIZE

drivers/crypto/stm32/stm32-cryp.c

1236

if (req->cryptlen % AES_BLOCK_SIZE)

drivers/crypto/stm32/stm32-cryp.c

1247

if (req->cryptlen % AES_BLOCK_SIZE)

drivers/crypto/stm32/stm32-cryp.c

1258

if (req->cryptlen % AES_BLOCK_SIZE)

drivers/crypto/stm32/stm32-cryp.c

1269

if (req->cryptlen % AES_BLOCK_SIZE)

drivers/crypto/stm32/stm32-cryp.c

1439

if (sg_is_last(sg) && !IS_ALIGNED(sg->length, AES_BLOCK_SIZE))

drivers/crypto/stm32/stm32-cryp.c

144

#define AES_BLOCK_32 (AES_BLOCK_SIZE / sizeof(u32))

drivers/crypto/stm32/stm32-cryp.c

1457

ret = stm32_cryp_dma_check_sg(in_sg, cryp->payload_in, AES_BLOCK_SIZE);

drivers/crypto/stm32/stm32-cryp.c

1461

ret = stm32_cryp_dma_check_sg(out_sg, cryp->payload_out, AES_BLOCK_SIZE);

drivers/crypto/stm32/stm32-cryp.c

1621

ret = stm32_cryp_dma_check_sg(cryp->header_sg, align_size, AES_BLOCK_SIZE);

drivers/crypto/stm32/stm32-cryp.c

1649

ret = stm32_cryp_dma_check_sg(cryp->in_sg, align_size, AES_BLOCK_SIZE);

drivers/crypto/stm32/stm32-cryp.c

1650

ret2 = stm32_cryp_dma_check_sg(cryp->out_sg, align_size, AES_BLOCK_SIZE);

drivers/crypto/stm32/stm32-cryp.c

1687

cryp->hw_blocksize = is_aes(cryp) ? AES_BLOCK_SIZE : DES_BLOCK_SIZE;

drivers/crypto/stm32/stm32-cryp.c

1852

memcpy(iv, cryp->areq->iv, AES_BLOCK_SIZE);

drivers/crypto/stm32/stm32-cryp.c

1853

memset(iv + AES_BLOCK_SIZE - 1 - iv[0], 0, iv[0] + 1);

drivers/crypto/stm32/stm32-cryp.c

2121

if (unlikely(cryp->payload_in < AES_BLOCK_SIZE &&

drivers/crypto/stm32/stm32-cryp.c

2135

if (unlikely((cryp->payload_in < AES_BLOCK_SIZE) &&

drivers/crypto/stm32/stm32-cryp.c

2160

written = min(AES_BLOCK_SIZE, cryp->header_in);

drivers/crypto/stm32/stm32-cryp.c

2289

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/stm32/stm32-cryp.c

2311

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/stm32/stm32-cryp.c

2319

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/stm32/stm32-cryp.c

2342

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/stm32/stm32-cryp.c

2451

.base.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/stm32/stm32-cryp.c

2473

.base.ivsize = AES_BLOCK_SIZE,

drivers/crypto/stm32/stm32-cryp.c

2474

.base.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/stm32/stm32-cryp.c

668

written = min_t(size_t, AES_BLOCK_SIZE - len, alen);

drivers/crypto/stm32/stm32-cryp.c

689

memcpy(iv, cryp->areq->iv, AES_BLOCK_SIZE);

drivers/crypto/stm32/stm32-cryp.c

690

memset(iv + AES_BLOCK_SIZE - 1 - iv[0], 0, iv[0] + 1);

drivers/crypto/stm32/stm32-cryp.c

691

iv[AES_BLOCK_SIZE - 1] = 1;

drivers/crypto/stm32/stm32-cryp.c

695

memcpy(b0, iv, AES_BLOCK_SIZE);

drivers/crypto/stm32/stm32-cryp.c

704

b0[AES_BLOCK_SIZE - 2] = textlen >> 8;

drivers/crypto/stm32/stm32-cryp.c

705

b0[AES_BLOCK_SIZE - 1] = textlen & 0xFF;

drivers/crypto/talitos.c

2272

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2276

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2294

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2298

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2364

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2368

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2386

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2390

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2456

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2460

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2478

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2482

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2548

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2552

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2593

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2597

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2638

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2642

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2660

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2664

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2727

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2741

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2746

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2762

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2778

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/tegra/tegra-se-aes.c

1477

data_count = (rctx->datbuf.size / AES_BLOCK_SIZE);

drivers/crypto/tegra/tegra-se-aes.c

1483

res_bits = (rctx->datbuf.size % AES_BLOCK_SIZE) * 8;

drivers/crypto/tegra/tegra-se-aes.c

1512

cpuvaddr[i++] = SE_ADDR_HI_SZ(AES_BLOCK_SIZE);

drivers/crypto/tegra/tegra-se-aes.c

1920

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/tegra/tegra-se-aes.c

1942

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/tegra/tegra-se-aes.c

1943

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/tegra/tegra-se-aes.c

1944

.chunksize = AES_BLOCK_SIZE,

drivers/crypto/tegra/tegra-se-aes.c

1971

.halg.digestsize = AES_BLOCK_SIZE,

drivers/crypto/tegra/tegra-se-aes.c

1978

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/tegra/tegra-se-aes.c

216

data_count = rctx->len / AES_BLOCK_SIZE;

drivers/crypto/tegra/tegra-se-aes.c

217

res_bits = (rctx->len % AES_BLOCK_SIZE) * 8;

drivers/crypto/tegra/tegra-se-aes.c

279

if (rctx->len % AES_BLOCK_SIZE)

drivers/crypto/tegra/tegra-se-aes.c

280

rctx->len += AES_BLOCK_SIZE - (rctx->len % AES_BLOCK_SIZE);

drivers/crypto/tegra/tegra-se-aes.c

527

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/tegra/tegra-se-aes.c

533

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/tegra/tegra-se-aes.c

554

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/tegra/tegra-se-aes.c

570

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/tegra/tegra-se-aes.c

592

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/tegra/tegra-se-aes.c

598

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/tegra/tegra-se-aes.c

614

data_count = (rctx->assoclen / AES_BLOCK_SIZE);

drivers/crypto/tegra/tegra-se-aes.c

615

res_bits = (rctx->assoclen % AES_BLOCK_SIZE) * 8;

drivers/crypto/tegra/tegra-se-aes.c

654

data_count = (rctx->cryptlen / AES_BLOCK_SIZE);

drivers/crypto/tegra/tegra-se-aes.c

655

res_bits = (rctx->cryptlen % AES_BLOCK_SIZE) * 8;

drivers/crypto/tegra/tegra-se-aes.c

861

data_count = (rctx->inbuf.size / AES_BLOCK_SIZE) - 1;

drivers/crypto/tegra/tegra-se-aes.c

902

cpuvaddr[i++] = (rctx->inbuf.size / AES_BLOCK_SIZE) - 1;

drivers/crypto/ti/dthev2-aes.c

412

if (req->cryptlen % AES_BLOCK_SIZE) {

drivers/crypto/ti/dthev2-aes.c

472

.cra_alignmask = AES_BLOCK_SIZE - 1,

drivers/crypto/ti/dthev2-aes.c

473

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/ti/dthev2-aes.c

495

.cra_alignmask = AES_BLOCK_SIZE - 1,

drivers/crypto/ti/dthev2-aes.c

496

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/ti/dthev2-aes.c

520

.cra_alignmask = AES_BLOCK_SIZE - 1,

drivers/crypto/ti/dthev2-aes.c

521

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/ti/dthev2-aes.c

88

#define AES_IV_SIZE AES_BLOCK_SIZE

drivers/crypto/ti/dthev2-aes.c

89

#define AES_BLOCK_WORDS (AES_BLOCK_SIZE / sizeof(u32))

drivers/crypto/virtio/virtio_crypto_skcipher_algs.c

425

req->cryptlen - AES_BLOCK_SIZE,

drivers/crypto/virtio/virtio_crypto_skcipher_algs.c

426

AES_BLOCK_SIZE, 0);

drivers/crypto/virtio/virtio_crypto_skcipher_algs.c

477

if (req->cryptlen % AES_BLOCK_SIZE)

drivers/crypto/virtio/virtio_crypto_skcipher_algs.c

500

if (req->cryptlen % AES_BLOCK_SIZE)

drivers/crypto/virtio/virtio_crypto_skcipher_algs.c

554

req->cryptlen - AES_BLOCK_SIZE,

drivers/crypto/virtio/virtio_crypto_skcipher_algs.c

555

AES_BLOCK_SIZE, 0);

drivers/crypto/virtio/virtio_crypto_skcipher_algs.c

572

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/virtio/virtio_crypto_skcipher_algs.c

582

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/xilinx/xilinx-trng.c

202

TRNG_SEED_LEN_BYTES, &seedlist, AES_BLOCK_SIZE,

drivers/crypto/xilinx/xilinx-trng.c

356

sb_size = crypto_drbg_ctr_df_datalen(TRNG_SEED_LEN_BYTES, AES_BLOCK_SIZE);

drivers/net/phy/mscc/mscc_macsec.c

506

const u8 input[AES_BLOCK_SIZE] = {0};

drivers/s390/crypto/zcrypt_ep11misc.c

1452

wkbuflen = (keylen + AES_BLOCK_SIZE) & (~(AES_BLOCK_SIZE - 1));

drivers/staging/rtl8723bs/core/rtw_security.c

1362

for (i = 0; i < AES_BLOCK_SIZE - 1; i++)

drivers/staging/rtl8723bs/core/rtw_security.c

1365

pad[AES_BLOCK_SIZE - 1] <<= 1;

drivers/staging/rtl8723bs/core/rtw_security.c

1367

pad[AES_BLOCK_SIZE - 1] ^= 0x87;

drivers/staging/rtl8723bs/core/rtw_security.c

1387

u8 cbc[AES_BLOCK_SIZE], pad[AES_BLOCK_SIZE];

drivers/staging/rtl8723bs/core/rtw_security.c

1395

memset(cbc, 0, AES_BLOCK_SIZE);

drivers/staging/rtl8723bs/core/rtw_security.c

1406

while (left >= AES_BLOCK_SIZE) {

drivers/staging/rtl8723bs/core/rtw_security.c

1407

for (i = 0; i < AES_BLOCK_SIZE; i++) {

drivers/staging/rtl8723bs/core/rtw_security.c

1415

if (left > AES_BLOCK_SIZE)

drivers/staging/rtl8723bs/core/rtw_security.c

1417

left -= AES_BLOCK_SIZE;

drivers/staging/rtl8723bs/core/rtw_security.c

1420

memset(pad, 0, AES_BLOCK_SIZE);

drivers/staging/rtl8723bs/core/rtw_security.c

1437

for (i = 0; i < AES_BLOCK_SIZE; i++)

drivers/ufs/host/ufs-exynos.c

1348

profile->max_dun_bytes_supported = AES_BLOCK_SIZE;

include/crypto/aes.h

311

void aes_encrypt(aes_encrypt_arg key, u8 out[at_least AES_BLOCK_SIZE],

include/crypto/aes.h

312

const u8 in[at_least AES_BLOCK_SIZE]);

include/crypto/aes.h

322

void aes_decrypt(const struct aes_key *key, u8 out[at_least AES_BLOCK_SIZE],

include/crypto/aes.h

323

const u8 in[at_least AES_BLOCK_SIZE]);

include/crypto/aes.h

331

int len, const u8 iv[AES_BLOCK_SIZE]);

include/crypto/aes.h

333

int len, const u8 iv[AES_BLOCK_SIZE]);

lib/crypto/aes.c

345

u8 out[AES_BLOCK_SIZE],

lib/crypto/aes.c

346

const u8 in[AES_BLOCK_SIZE])

lib/crypto/aes.c

403

u8 out[AES_BLOCK_SIZE],

lib/crypto/aes.c

404

const u8 in[AES_BLOCK_SIZE])

lib/crypto/aes.c

461

u8 out[AES_BLOCK_SIZE],

lib/crypto/aes.c

462

const u8 in[AES_BLOCK_SIZE])

lib/crypto/aes.c

468

u8 out[AES_BLOCK_SIZE],

lib/crypto/aes.c

469

const u8 in[AES_BLOCK_SIZE])

lib/crypto/aes.c

501

void aes_encrypt(aes_encrypt_arg key, u8 out[AES_BLOCK_SIZE],

lib/crypto/aes.c

502

const u8 in[AES_BLOCK_SIZE])

lib/crypto/aes.c

508

void aes_decrypt(const struct aes_key *key, u8 out[AES_BLOCK_SIZE],

lib/crypto/aes.c

509

const u8 in[AES_BLOCK_SIZE])

lib/crypto/aescfb.c

112

u8 iv[AES_BLOCK_SIZE] __nonstring;

lib/crypto/aescfb.c

42

int len, const u8 iv[AES_BLOCK_SIZE])

lib/crypto/aescfb.c

44

u8 ks[AES_BLOCK_SIZE];

lib/crypto/aescfb.c

49

crypto_xor_cpy(dst, src, ks, min(len, AES_BLOCK_SIZE));

lib/crypto/aescfb.c

52

dst += AES_BLOCK_SIZE;

lib/crypto/aescfb.c

53

src += AES_BLOCK_SIZE;

lib/crypto/aescfb.c

54

len -= AES_BLOCK_SIZE;

lib/crypto/aescfb.c

71

int len, const u8 iv[AES_BLOCK_SIZE])

lib/crypto/aescfb.c

73

u8 ks[2][AES_BLOCK_SIZE];

lib/crypto/aescfb.c

78

if (len > AES_BLOCK_SIZE)

lib/crypto/aescfb.c

86

crypto_xor_cpy(dst, src, ks[i], min(len, AES_BLOCK_SIZE));

lib/crypto/aescfb.c

88

dst += AES_BLOCK_SIZE;

lib/crypto/aescfb.c

89

src += AES_BLOCK_SIZE;

lib/crypto/aescfb.c

90

len -= AES_BLOCK_SIZE;

lib/crypto/aesgcm.c

110

u8 buf[AES_BLOCK_SIZE];

lib/crypto/aesgcm.c

123

crypto_xor_cpy(dst, src, buf, min(len, AES_BLOCK_SIZE));

lib/crypto/aesgcm.c

125

dst += AES_BLOCK_SIZE;

lib/crypto/aesgcm.c

126

src += AES_BLOCK_SIZE;

lib/crypto/aesgcm.c

127

len -= AES_BLOCK_SIZE;

lib/crypto/aesgcm.c

182

u8 tagbuf[AES_BLOCK_SIZE];

lib/crypto/aesgcm.c

48

u8 kin[AES_BLOCK_SIZE] = {};

lib/crypto/aesgcm.c

696

u8 tagbuf[AES_BLOCK_SIZE];

lib/crypto/aesgcm.c

92

u8 buf[AES_BLOCK_SIZE];

lib/crypto/arm/aes.h

10

const u8 in[AES_BLOCK_SIZE],

lib/crypto/arm/aes.h

11

u8 out[AES_BLOCK_SIZE]);

lib/crypto/arm/aes.h

13

const u8 in[AES_BLOCK_SIZE],

lib/crypto/arm/aes.h

14

u8 out[AES_BLOCK_SIZE]);

lib/crypto/arm/aes.h

25

u8 out[AES_BLOCK_SIZE],

lib/crypto/arm/aes.h

26

const u8 in[AES_BLOCK_SIZE])

lib/crypto/arm/aes.h

30

u8 bounce_buf[AES_BLOCK_SIZE] __aligned(4);

lib/crypto/arm/aes.h

32

memcpy(bounce_buf, in, AES_BLOCK_SIZE);

lib/crypto/arm/aes.h

35

memcpy(out, bounce_buf, AES_BLOCK_SIZE);

lib/crypto/arm/aes.h

42

u8 out[AES_BLOCK_SIZE],

lib/crypto/arm/aes.h

43

const u8 in[AES_BLOCK_SIZE])

lib/crypto/arm/aes.h

47

u8 bounce_buf[AES_BLOCK_SIZE] __aligned(4);

lib/crypto/arm/aes.h

49

memcpy(bounce_buf, in, AES_BLOCK_SIZE);

lib/crypto/arm/aes.h

52

memcpy(out, bounce_buf, AES_BLOCK_SIZE);

lib/crypto/arm64/aes.h

130

u8 out[AES_BLOCK_SIZE],

lib/crypto/arm64/aes.h

131

const u8 in[AES_BLOCK_SIZE])

lib/crypto/arm64/aes.h

143

u8 out[AES_BLOCK_SIZE],

lib/crypto/arm64/aes.h

144

const u8 in[AES_BLOCK_SIZE])

lib/crypto/arm64/aes.h

17

u8 b[AES_BLOCK_SIZE];

lib/crypto/arm64/aes.h

20

asmlinkage void __aes_arm64_encrypt(const u32 rk[], u8 out[AES_BLOCK_SIZE],

lib/crypto/arm64/aes.h

21

const u8 in[AES_BLOCK_SIZE], int rounds);

lib/crypto/arm64/aes.h

22

asmlinkage void __aes_arm64_decrypt(const u32 inv_rk[], u8 out[AES_BLOCK_SIZE],

lib/crypto/arm64/aes.h

23

const u8 in[AES_BLOCK_SIZE], int rounds);

lib/crypto/arm64/aes.h

24

asmlinkage void __aes_ce_encrypt(const u32 rk[], u8 out[AES_BLOCK_SIZE],

lib/crypto/arm64/aes.h

25

const u8 in[AES_BLOCK_SIZE], int rounds);

lib/crypto/arm64/aes.h

26

asmlinkage void __aes_ce_decrypt(const u32 inv_rk[], u8 out[AES_BLOCK_SIZE],

lib/crypto/arm64/aes.h

27

const u8 in[AES_BLOCK_SIZE], int rounds);

lib/crypto/powerpc/aes.h

167

u8 out[AES_BLOCK_SIZE],

lib/crypto/powerpc/aes.h

168

const u8 in[AES_BLOCK_SIZE])

lib/crypto/powerpc/aes.h

196

static void aes_decrypt_arch(const struct aes_key *key, u8 out[AES_BLOCK_SIZE],

lib/crypto/powerpc/aes.h

197

const u8 in[AES_BLOCK_SIZE])

lib/crypto/powerpc/aes.h

62

u8 out[AES_BLOCK_SIZE],

lib/crypto/powerpc/aes.h

63

const u8 in[AES_BLOCK_SIZE])

lib/crypto/powerpc/aes.h

71

u8 out[AES_BLOCK_SIZE],

lib/crypto/powerpc/aes.h

72

const u8 in[AES_BLOCK_SIZE])

lib/crypto/riscv/aes.h

14

u8 out[AES_BLOCK_SIZE], const u8 in[AES_BLOCK_SIZE]);

lib/crypto/riscv/aes.h

16

u8 out[AES_BLOCK_SIZE], const u8 in[AES_BLOCK_SIZE]);

lib/crypto/riscv/aes.h

27

u8 out[AES_BLOCK_SIZE],

lib/crypto/riscv/aes.h

28

const u8 in[AES_BLOCK_SIZE])

lib/crypto/riscv/aes.h

40

u8 out[AES_BLOCK_SIZE],

lib/crypto/riscv/aes.h

41

const u8 in[AES_BLOCK_SIZE])

lib/crypto/s390/aes.h

45

u8 out[AES_BLOCK_SIZE],

lib/crypto/s390/aes.h

46

const u8 in[AES_BLOCK_SIZE], int decrypt)

lib/crypto/s390/aes.h

52

AES_BLOCK_SIZE);

lib/crypto/s390/aes.h

59

AES_BLOCK_SIZE);

lib/crypto/s390/aes.h

66

AES_BLOCK_SIZE);

lib/crypto/s390/aes.h

74

u8 out[AES_BLOCK_SIZE],

lib/crypto/s390/aes.h

75

const u8 in[AES_BLOCK_SIZE])

lib/crypto/s390/aes.h

83

u8 out[AES_BLOCK_SIZE],

lib/crypto/s390/aes.h

84

const u8 in[AES_BLOCK_SIZE])

lib/crypto/sparc/aes.h

117

u8 out[AES_BLOCK_SIZE],

lib/crypto/sparc/aes.h

118

const u8 in[AES_BLOCK_SIZE])

lib/crypto/sparc/aes.h

120

u32 bounce_buf[AES_BLOCK_SIZE / 4];

lib/crypto/sparc/aes.h

126

memcpy(bounce_buf, in, AES_BLOCK_SIZE);

lib/crypto/sparc/aes.h

128

memcpy(out, bounce_buf, AES_BLOCK_SIZE);

lib/crypto/sparc/aes.h

87

u8 out[AES_BLOCK_SIZE],

lib/crypto/sparc/aes.h

88

const u8 in[AES_BLOCK_SIZE])

lib/crypto/sparc/aes.h

90

u32 bounce_buf[AES_BLOCK_SIZE / 4];

lib/crypto/sparc/aes.h

96

memcpy(bounce_buf, in, AES_BLOCK_SIZE);

lib/crypto/sparc/aes.h

98

memcpy(out, bounce_buf, AES_BLOCK_SIZE);

lib/crypto/x86/aes.h

17

u8 out[AES_BLOCK_SIZE], const u8 in[AES_BLOCK_SIZE]);

lib/crypto/x86/aes.h

19

u8 out[AES_BLOCK_SIZE], const u8 in[AES_BLOCK_SIZE]);

lib/crypto/x86/aes.h

53

u8 out[AES_BLOCK_SIZE],

lib/crypto/x86/aes.h

54

const u8 in[AES_BLOCK_SIZE])

lib/crypto/x86/aes.h

66

u8 out[AES_BLOCK_SIZE],

lib/crypto/x86/aes.h

67

const u8 in[AES_BLOCK_SIZE])

net/ceph/crypto.c

270

char iv[AES_BLOCK_SIZE] __aligned(8);

net/ceph/crypto.c

271

int pad_byte = AES_BLOCK_SIZE - (in_len & (AES_BLOCK_SIZE - 1));

net/ceph/crypto.c

282

memcpy(iv, aes_iv, AES_BLOCK_SIZE);

net/ceph/crypto.c

312

if (pad_byte > 0 && pad_byte <= AES_BLOCK_SIZE &&

net/ceph/crypto.c

343

sgt.sgl, sgt.nents, buf_len, AES_BLOCK_SIZE,

net/ceph/crypto.c

381

WARN_ON(data_off != AES_BLOCK_SIZE);

net/ceph/crypto.c

418

return AES_BLOCK_SIZE;

net/ceph/crypto.c

431

return data_len + AES_BLOCK_SIZE -

net/ceph/crypto.c

432

(data_len & (AES_BLOCK_SIZE - 1));

net/ceph/crypto.c

435

return AES_BLOCK_SIZE + data_len + 24;

net/mac80211/aes_cmac.c

29

u8 out[AES_BLOCK_SIZE];

net/mac80211/aes_gmac.c

21

u8 *zero, *__aad, iv[AES_BLOCK_SIZE];

net/mac80211/aes_gmac.c

59

iv[AES_BLOCK_SIZE - 1] = 0x01;

net/mac80211/fils_aead.c

106

memcpy(out, v, AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

133

sg_init_one(dst, out + AES_BLOCK_SIZE, plain_len);

net/mac80211/fils_aead.c

155

u8 frame_iv[AES_BLOCK_SIZE], iv[AES_BLOCK_SIZE];

net/mac80211/fils_aead.c

156

u8 check[AES_BLOCK_SIZE];

net/mac80211/fils_aead.c

158

crypt_len = iv_c_len - AES_BLOCK_SIZE;

net/mac80211/fils_aead.c

164

memcpy(iv, iv_crypt, AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

165

memcpy(frame_iv, iv_crypt, AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

191

sg_init_one(src, iv_crypt + AES_BLOCK_SIZE, crypt_len);

net/mac80211/fils_aead.c

212

if (memcmp(check, frame_iv, AES_BLOCK_SIZE) != 0)

net/mac80211/fils_aead.c

263

skb_put(skb, AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

28

u8 d[AES_BLOCK_SIZE], tmp[AES_BLOCK_SIZE] = {};

net/mac80211/fils_aead.c

317

if (crypt_len < AES_BLOCK_SIZE) {

net/mac80211/fils_aead.c

331

*frame_len -= AES_BLOCK_SIZE;

net/mac80211/fils_aead.c

35

crypto_shash_digest(desc, tmp, AES_BLOCK_SIZE, d);

net/mac80211/fils_aead.c

41

crypto_xor(d, tmp, AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

46

if (len[i] >= AES_BLOCK_SIZE) {

net/mac80211/fils_aead.c

49

crypto_shash_update(desc, addr[i], len[i] - AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

50

crypto_xor(d, addr[i] + len[i] - AES_BLOCK_SIZE,

net/mac80211/fils_aead.c

51

AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

60

crypto_shash_finup(desc, d, AES_BLOCK_SIZE, v);

net/mac80211/fils_aead.c

71

u8 v[AES_BLOCK_SIZE];

net/mac80211/wpa.c

437

u8 b_0[AES_BLOCK_SIZE];

net/mac80211/wpa.c

567

u8 aad[2 * AES_BLOCK_SIZE];

net/mac80211/wpa.c

568

u8 b_0[AES_BLOCK_SIZE];

net/mac80211/wpa.c

638

u8 j_0[AES_BLOCK_SIZE];

net/mac80211/wpa.c

764

u8 aad[2 * AES_BLOCK_SIZE];

net/mac80211/wpa.c

765

u8 j_0[AES_BLOCK_SIZE];

security/keys/encrypted-keys/encrypted.c

435

u8 iv[AES_BLOCK_SIZE];

security/keys/encrypted-keys/encrypted.c

449

sg_set_page(&sg_in[1], ZERO_PAGE(0), AES_BLOCK_SIZE, 0);

security/keys/encrypted-keys/encrypted.c

536

u8 iv[AES_BLOCK_SIZE];

security/keys/encrypted-keys/encrypted.c

541

pad = kmalloc(AES_BLOCK_SIZE, GFP_KERNEL);

security/keys/encrypted-keys/encrypted.c

557

sg_set_buf(&sg_out[1], pad, AES_BLOCK_SIZE);

security/keys/trusted-keys/trusted_dcp.c

307

buf = kmalloc(AES_BLOCK_SIZE, GFP_KERNEL);

security/keys/trusted-keys/trusted_dcp.c

313

memset(buf, 0x55, AES_BLOCK_SIZE);

security/keys/trusted-keys/trusted_dcp.c

319

if (memcmp(buf, bad, AES_BLOCK_SIZE) == 0) {