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

182

u8 buf[AES_BLOCK_SIZE];

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

200

while (walk.nbytes >= AES_BLOCK_SIZE) {

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

201

int nblocks = walk.nbytes / AES_BLOCK_SIZE;

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

208

src += nblocks * AES_BLOCK_SIZE;

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

209

dst += nblocks * AES_BLOCK_SIZE;

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

216

walk.nbytes % AES_BLOCK_SIZE);

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

231

tail = walk.nbytes % AES_BLOCK_SIZE;

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

270

u8 otag[AES_BLOCK_SIZE];

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

271

u8 buf[AES_BLOCK_SIZE];

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

293

while (walk.nbytes >= AES_BLOCK_SIZE) {

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

294

int nblocks = walk.nbytes / AES_BLOCK_SIZE;

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

301

src += nblocks * AES_BLOCK_SIZE;

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

302

dst += nblocks * AES_BLOCK_SIZE;

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

309

walk.nbytes % AES_BLOCK_SIZE);

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

323

tail = walk.nbytes % AES_BLOCK_SIZE;

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

402

.chunksize = AES_BLOCK_SIZE,

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

403

.maxauthsize = AES_BLOCK_SIZE,

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

417

.chunksize = AES_BLOCK_SIZE,

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

418

.maxauthsize = AES_BLOCK_SIZE,

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

85

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

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

101

u32 blocks = abytes / AES_BLOCK_SIZE;

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

103

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

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

106

macp = enc_after ? 0 : AES_BLOCK_SIZE;

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

107

in += blocks * AES_BLOCK_SIZE;

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

108

abytes -= blocks * AES_BLOCK_SIZE;

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

110

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

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

129

u32 macp = AES_BLOCK_SIZE;

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

161

u8 __aligned(8) mac[AES_BLOCK_SIZE];

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

162

u8 orig_iv[AES_BLOCK_SIZE];

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

171

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

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

182

u32 tail = walk.nbytes % AES_BLOCK_SIZE;

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

185

u8 buf[AES_BLOCK_SIZE];

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

193

if (unlikely(walk.nbytes < AES_BLOCK_SIZE))

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

201

if (unlikely(walk.nbytes < AES_BLOCK_SIZE))

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

226

u8 __aligned(8) mac[AES_BLOCK_SIZE];

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

227

u8 orig_iv[AES_BLOCK_SIZE];

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

236

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

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

247

u32 tail = walk.nbytes % AES_BLOCK_SIZE;

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

250

u8 buf[AES_BLOCK_SIZE];

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

258

if (unlikely(walk.nbytes < AES_BLOCK_SIZE))

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

266

if (unlikely(walk.nbytes < AES_BLOCK_SIZE))

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

297

.ivsize = AES_BLOCK_SIZE,

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

298

.chunksize = AES_BLOCK_SIZE,

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

299

.maxauthsize = AES_BLOCK_SIZE,

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

60

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

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

78

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

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

91

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

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

98

int enc_after = (macp + abytes) % AES_BLOCK_SIZE;

arch/arm64/crypto/aes-glue.c

133

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

arch/arm64/crypto/aes-glue.c

137

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

arch/arm64/crypto/aes-glue.c

152

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

arch/arm64/crypto/aes-glue.c

156

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

arch/arm64/crypto/aes-glue.c

169

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

arch/arm64/crypto/aes-glue.c

173

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

arch/arm64/crypto/aes-glue.c

197

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

arch/arm64/crypto/aes-glue.c

201

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

arch/arm64/crypto/aes-glue.c

222

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

arch/arm64/crypto/aes-glue.c

232

if (req->cryptlen <= AES_BLOCK_SIZE) {

arch/arm64/crypto/aes-glue.c

233

if (req->cryptlen < AES_BLOCK_SIZE)

arch/arm64/crypto/aes-glue.c

240

cbc_blocks * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

248

if (req->cryptlen == AES_BLOCK_SIZE)

arch/arm64/crypto/aes-glue.c

259

req->cryptlen - cbc_blocks * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

278

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

arch/arm64/crypto/aes-glue.c

288

if (req->cryptlen <= AES_BLOCK_SIZE) {

arch/arm64/crypto/aes-glue.c

289

if (req->cryptlen < AES_BLOCK_SIZE)

arch/arm64/crypto/aes-glue.c

296

cbc_blocks * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

304

if (req->cryptlen == AES_BLOCK_SIZE)

arch/arm64/crypto/aes-glue.c

315

req->cryptlen - cbc_blocks * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

339

blocks = walk.nbytes / AES_BLOCK_SIZE;

arch/arm64/crypto/aes-glue.c

346

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

arch/arm64/crypto/aes-glue.c

361

blocks = walk.nbytes / AES_BLOCK_SIZE;

arch/arm64/crypto/aes-glue.c

368

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

arch/arm64/crypto/aes-glue.c

387

u8 buf[AES_BLOCK_SIZE];

arch/arm64/crypto/aes-glue.c

397

if (unlikely(nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/aes-glue.c

401

nbytes &= ~(AES_BLOCK_SIZE - 1);

arch/arm64/crypto/aes-glue.c

407

if (unlikely(nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/aes-glue.c

431

u8 buf[AES_BLOCK_SIZE];

arch/arm64/crypto/aes-glue.c

441

if (unlikely(nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/aes-glue.c

445

nbytes &= ~(AES_BLOCK_SIZE - 1);

arch/arm64/crypto/aes-glue.c

451

if (unlikely(nbytes < AES_BLOCK_SIZE))

arch/arm64/crypto/aes-glue.c

466

int tail = req->cryptlen % AES_BLOCK_SIZE;

arch/arm64/crypto/aes-glue.c

472

if (req->cryptlen < AES_BLOCK_SIZE)

arch/arm64/crypto/aes-glue.c

479

AES_BLOCK_SIZE) - 2;

arch/arm64/crypto/aes-glue.c

488

xts_blocks * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

497

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

arch/arm64/crypto/aes-glue.c

501

nbytes &= ~(AES_BLOCK_SIZE - 1);

arch/arm64/crypto/aes-glue.c

516

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

arch/arm64/crypto/aes-glue.c

535

int tail = req->cryptlen % AES_BLOCK_SIZE;

arch/arm64/crypto/aes-glue.c

541

if (req->cryptlen < AES_BLOCK_SIZE)

arch/arm64/crypto/aes-glue.c

548

AES_BLOCK_SIZE) - 2;

arch/arm64/crypto/aes-glue.c

557

xts_blocks * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

566

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

arch/arm64/crypto/aes-glue.c

570

nbytes &= ~(AES_BLOCK_SIZE - 1);

arch/arm64/crypto/aes-glue.c

585

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

arch/arm64/crypto/aes-glue.c

605

.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

619

.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

625

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

640

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

641

.chunksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

656

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

657

.chunksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

666

.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

672

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

673

.walksize = 2 * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

683

.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

689

.ivsize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

690

.walksize = 2 * AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

699

.cra_blocksize = AES_BLOCK_SIZE,

arch/arm64/crypto/aes-glue.c

705

.ivsize = AES_BLOCK_SIZE,

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

102

walk.stride / AES_BLOCK_SIZE);

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

108

walk.nbytes - blocks * AES_BLOCK_SIZE);

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

159

while (walk.nbytes >= AES_BLOCK_SIZE) {

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

160

unsigned int blocks = walk.nbytes / AES_BLOCK_SIZE;

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

168

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

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

182

while (walk.nbytes >= AES_BLOCK_SIZE) {

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

183

unsigned int blocks = walk.nbytes / AES_BLOCK_SIZE;

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

187

walk.stride / AES_BLOCK_SIZE);

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

194

walk.nbytes - blocks * AES_BLOCK_SIZE);

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

210

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

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

211

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

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

220

dst += blocks * AES_BLOCK_SIZE;

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

221

src += blocks * AES_BLOCK_SIZE;

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

224

u8 buf[AES_BLOCK_SIZE];

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

227

if (unlikely(nbytes < AES_BLOCK_SIZE))

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

235

if (unlikely(nbytes < AES_BLOCK_SIZE))

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

277

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

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

287

if (req->cryptlen < AES_BLOCK_SIZE)

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

291

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

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

293

AES_BLOCK_SIZE) - 2;

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

300

xts_blocks * AES_BLOCK_SIZE,

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

312

while (walk.nbytes >= AES_BLOCK_SIZE) {

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

313

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

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

328

out += blocks * AES_BLOCK_SIZE;

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

329

in += blocks * AES_BLOCK_SIZE;

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

330

nbytes -= blocks * AES_BLOCK_SIZE;

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

354

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

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

392

.base.cra_blocksize = AES_BLOCK_SIZE,

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

398

.walksize = 8 * AES_BLOCK_SIZE,

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

406

.base.cra_blocksize = AES_BLOCK_SIZE,

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

412

.walksize = 8 * AES_BLOCK_SIZE,

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

413

.ivsize = AES_BLOCK_SIZE,

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

427

.chunksize = AES_BLOCK_SIZE,

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

428

.walksize = 8 * AES_BLOCK_SIZE,

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

429

.ivsize = AES_BLOCK_SIZE,

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

437

.base.cra_blocksize = AES_BLOCK_SIZE,

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

443

.walksize = 8 * AES_BLOCK_SIZE,

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

444

.ivsize = AES_BLOCK_SIZE,

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

47

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

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

49

} __aligned(AES_BLOCK_SIZE);

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

97

while (walk.nbytes >= AES_BLOCK_SIZE) {

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

98

unsigned int blocks = walk.nbytes / AES_BLOCK_SIZE;

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

169

u8 buf[AES_BLOCK_SIZE];

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

192

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

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

196

nbytes &= ~(AES_BLOCK_SIZE - 1);

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

208

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

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

231

u8 otag[AES_BLOCK_SIZE];

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

232

u8 buf[AES_BLOCK_SIZE];

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

260

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

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

264

nbytes &= ~(AES_BLOCK_SIZE - 1);

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

278

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

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

293

u8 iv[AES_BLOCK_SIZE];

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

301

u8 iv[AES_BLOCK_SIZE];

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

331

u8 iv[AES_BLOCK_SIZE];

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

344

u8 iv[AES_BLOCK_SIZE];

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

355

.chunksize = AES_BLOCK_SIZE,

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

356

.maxauthsize = AES_BLOCK_SIZE,

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

370

.chunksize = AES_BLOCK_SIZE,

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

371

.maxauthsize = AES_BLOCK_SIZE,

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

85

aes_encrypt(&ctx->aes_key, key, (u8[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

145

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

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

184

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

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

226

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

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

253

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

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

277

int tail = req->cryptlen % AES_BLOCK_SIZE;

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

278

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

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

280

u8 b[2][AES_BLOCK_SIZE];

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

283

if (req->cryptlen < AES_BLOCK_SIZE)

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

297

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

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

299

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

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

302

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

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

306

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

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

315

int tail = req->cryptlen % AES_BLOCK_SIZE;

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

316

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

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

318

u8 b[3][AES_BLOCK_SIZE];

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

322

if (req->cryptlen < AES_BLOCK_SIZE)

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

336

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

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

341

AES_BLOCK_SIZE);

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

345

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

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

348

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

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

349

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

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

353

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

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

371

.base.cra_blocksize = AES_BLOCK_SIZE,

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

383

.base.cra_blocksize = AES_BLOCK_SIZE,

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

388

.ivsize = AES_BLOCK_SIZE,

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

401

.ivsize = AES_BLOCK_SIZE,

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

405

.chunksize = AES_BLOCK_SIZE,

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

410

.base.cra_blocksize = AES_BLOCK_SIZE,

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

415

.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

105

nbytes & ~(AES_BLOCK_SIZE - 1));

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

109

nbytes & ~(AES_BLOCK_SIZE - 1));

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

111

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

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

143

nbytes & ~(AES_BLOCK_SIZE - 1),

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

148

nbytes & ~(AES_BLOCK_SIZE - 1),

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

151

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

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

180

if (req->cryptlen < AES_BLOCK_SIZE)

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

193

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

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

194

AES_BLOCK_SIZE);

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

249

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

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

250

nblocks = nbytes / AES_BLOCK_SIZE;

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

253

nblocks = DIV_ROUND_UP(nbytes, AES_BLOCK_SIZE);

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

270

p1_nbytes = min(nbytes, (nblocks - ctr32) * 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

32

u8 iv[AES_BLOCK_SIZE]);

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

320

if (req->cryptlen < AES_BLOCK_SIZE)

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

343

req->cryptlen - tail - AES_BLOCK_SIZE,

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

35

u8 iv[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

39

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

421

.cra_blocksize = AES_BLOCK_SIZE,

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

43

u8 iv[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

470

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

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

48

u8 tweak[AES_BLOCK_SIZE]);

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

53

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

137

nbytes &= AES_BLOCK_SIZE - 1;

arch/x86/crypto/aesni-intel_glue.c

1389

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

1392

le_ctr[0] += nbytes / AES_BLOCK_SIZE;

arch/x86/crypto/aesni-intel_glue.c

1480

.chunksize = AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

1496

.chunksize = AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

159

nbytes &= AES_BLOCK_SIZE - 1;

arch/x86/crypto/aesni-intel_glue.c

181

nbytes &= AES_BLOCK_SIZE - 1;

arch/x86/crypto/aesni-intel_glue.c

203

nbytes &= AES_BLOCK_SIZE - 1;

arch/x86/crypto/aesni-intel_glue.c

214

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

arch/x86/crypto/aesni-intel_glue.c

225

if (req->cryptlen <= AES_BLOCK_SIZE) {

arch/x86/crypto/aesni-intel_glue.c

226

if (req->cryptlen < AES_BLOCK_SIZE)

arch/x86/crypto/aesni-intel_glue.c

233

cbc_blocks * AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

240

if (req->cryptlen == AES_BLOCK_SIZE)

arch/x86/crypto/aesni-intel_glue.c

251

req->cryptlen - cbc_blocks * AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

270

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

arch/x86/crypto/aesni-intel_glue.c

281

if (req->cryptlen <= AES_BLOCK_SIZE) {

arch/x86/crypto/aesni-intel_glue.c

282

if (req->cryptlen < AES_BLOCK_SIZE)

arch/x86/crypto/aesni-intel_glue.c

289

cbc_blocks * AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

296

if (req->cryptlen == AES_BLOCK_SIZE)

arch/x86/crypto/aesni-intel_glue.c

307

req->cryptlen - cbc_blocks * AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

328

u8 keystream[AES_BLOCK_SIZE];

arch/x86/crypto/aesni-intel_glue.c

348

crypto_inc(walk.iv, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

380

u8 iv[AES_BLOCK_SIZE]);

arch/x86/crypto/aesni-intel_glue.c

383

u8 tweak[AES_BLOCK_SIZE]);

arch/x86/crypto/aesni-intel_glue.c

391

int tail = req->cryptlen % AES_BLOCK_SIZE;

arch/x86/crypto/aesni-intel_glue.c

410

req->cryptlen - tail - AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

421

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

arch/x86/crypto/aesni-intel_glue.c

424

walk.nbytes & (AES_BLOCK_SIZE - 1));

arch/x86/crypto/aesni-intel_glue.c

436

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

arch/x86/crypto/aesni-intel_glue.c

44

#define AES_BLOCK_MASK (~(AES_BLOCK_SIZE - 1))

arch/x86/crypto/aesni-intel_glue.c

459

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

arch/x86/crypto/aesni-intel_glue.c

485

u8 iv[AES_BLOCK_SIZE])

arch/x86/crypto/aesni-intel_glue.c

492

u8 tweak[AES_BLOCK_SIZE])

arch/x86/crypto/aesni-intel_glue.c

499

u8 tweak[AES_BLOCK_SIZE])

arch/x86/crypto/aesni-intel_glue.c

520

.cra_blocksize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

534

.cra_blocksize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

540

.ivsize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

549

.cra_blocksize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

555

.ivsize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

556

.walksize = 2 * AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

572

.ivsize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

573

.chunksize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

583

.cra_blocksize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

589

.ivsize = AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

590

.walksize = 2 * AES_BLOCK_SIZE,

arch/x86/crypto/aesni-intel_glue.c

599

u8 iv[AES_BLOCK_SIZE]);

arch/x86/crypto/aesni-intel_glue.c

624

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

625

nblocks = nbytes / AES_BLOCK_SIZE;

arch/x86/crypto/aesni-intel_glue.c

628

nblocks = DIV_ROUND_UP(nbytes, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

644

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

arch/x86/crypto/aesni-intel_glue.c

670

const u8 iv[AES_BLOCK_SIZE], u64 ctr))

arch/x86/crypto/aesni-intel_glue.c

682

nbytes = round_down(nbytes, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

689

ctr += DIV_ROUND_UP(nbytes, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

699

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

arch/x86/crypto/aesni-intel_glue.c

702

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

arch/x86/crypto/aesni-intel_glue.c

726

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

arch/x86/crypto/aesni-intel_glue.c

737

.base.cra_blocksize = AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

742

.ivsize = AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

743

.walksize = 2 * AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

756

.ivsize = AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

757

.chunksize = AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

770

.ivsize = AES_BLOCK_SIZE, \

arch/x86/crypto/aesni-intel_glue.c

771

.chunksize = AES_BLOCK_SIZE, \

crypto/aes.c

135

.cra_blocksize = AES_BLOCK_SIZE,

crypto/aes.c

151

.base.cra_blocksize = AES_BLOCK_SIZE,

crypto/aes.c

154

.digestsize = AES_BLOCK_SIZE,

crypto/aes.c

172

.base.cra_blocksize = AES_BLOCK_SIZE,

crypto/aes.c

175

.digestsize = AES_BLOCK_SIZE,

crypto/aes.c

189

.base.cra_blocksize = AES_BLOCK_SIZE,

crypto/aes.c

192

.digestsize = AES_BLOCK_SIZE,

drivers/char/tpm/tpm2-sessions.c

114

u8 scratch[AES_KEY_BYTES + AES_BLOCK_SIZE];

drivers/char/tpm/tpm2-sessions.c

700

auth->tpm_nonce, AES_KEY_BYTES + AES_BLOCK_SIZE,

drivers/char/tpm/tpm2-sessions.c

881

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

169

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

560

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

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

568

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

1081

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/amcc/crypto4xx_core.c

1142

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/amcc/crypto4xx_core.c

1163

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/amcc/crypto4xx_core.c

546

u32 icv[AES_BLOCK_SIZE];

drivers/crypto/amcc/crypto4xx_core.c

680

&& (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

1014

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

drivers/crypto/atmel-aes.c

1038

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

drivers/crypto/atmel-aes.c

106

__be32 iv[AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/atmel-aes.c

1087

ctx->block_size = AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

1188

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

119

__be32 j0[AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/atmel-aes.c

120

u32 tag[AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/atmel-aes.c

1201

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

121

__be32 ghash[AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/atmel-aes.c

1210

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

1224

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

1293

dd->datalen -= AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

1334

padlen = atmel_aes_padlen(ivsize, AES_BLOCK_SIZE);

drivers/crypto/atmel-aes.c

1335

datalen = ivsize + padlen + AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

1394

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

drivers/crypto/atmel-aes.c

1417

dd->datalen -= AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

145

u8 lastc[AES_BLOCK_SIZE];

drivers/crypto/atmel-aes.c

1475

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

drivers/crypto/atmel-aes.c

1533

ctx->block_size = AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

1597

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

1648

u32 tweak[AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/atmel-aes.c

1649

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

drivers/crypto/atmel-aes.c

1660

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

drivers/crypto/atmel-aes.c

1661

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

drivers/crypto/atmel-aes.c

1743

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

1750

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

1826

__be32 iv[AES_BLOCK_SIZE / sizeof(u32)];

drivers/crypto/atmel-aes.c

2015

ctx->block_size = AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

2038

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2044

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2054

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2060

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2070

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2076

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2086

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2092

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2102

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2108

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/atmel-aes.c

2121

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

drivers/crypto/atmel-aes.c

382

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

drivers/crypto/atmel-aes.c

388

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

drivers/crypto/atmel-aes.c

511

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

drivers/crypto/atmel-aes.c

594

dd->datalen -= AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

596

if (dd->datalen < AES_BLOCK_SIZE)

drivers/crypto/atmel-aes.c

625

size_t padlen = atmel_aes_padlen(len, AES_BLOCK_SIZE);

drivers/crypto/atmel-aes.c

850

case AES_BLOCK_SIZE:

drivers/crypto/atmel-aes.c

950

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

drivers/crypto/atmel-aes.c

986

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

drivers/crypto/atmel-aes.c

995

datalen = AES_BLOCK_SIZE * (0x10000 - start);

drivers/crypto/axis/artpec6_crypto.c

1181

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

drivers/crypto/axis/artpec6_crypto.c

1182

AES_BLOCK_SIZE;

drivers/crypto/axis/artpec6_crypto.c

1286

if (req->cryptlen < AES_BLOCK_SIZE)

drivers/crypto/axis/artpec6_crypto.c

1796

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

drivers/crypto/axis/artpec6_crypto.c

2001

req_ctx->decryption_tag, AES_BLOCK_SIZE, false);

drivers/crypto/axis/artpec6_crypto.c

2016

if (authsize < AES_BLOCK_SIZE) {

drivers/crypto/axis/artpec6_crypto.c

2017

count = AES_BLOCK_SIZE - authsize;

drivers/crypto/axis/artpec6_crypto.c

2160

cipher_req->cryptlen - AES_BLOCK_SIZE,

drivers/crypto/axis/artpec6_crypto.c

2161

AES_BLOCK_SIZE, 0);

drivers/crypto/axis/artpec6_crypto.c

2172

cipher_req->cryptlen - AES_BLOCK_SIZE,

drivers/crypto/axis/artpec6_crypto.c

2173

AES_BLOCK_SIZE, 0);

drivers/crypto/axis/artpec6_crypto.c

2188

u8 input_tag[AES_BLOCK_SIZE];

drivers/crypto/axis/artpec6_crypto.c

2700

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/axis/artpec6_crypto.c

2729

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/axis/artpec6_crypto.c

2744

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/axis/artpec6_crypto.c

2751

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/axis/artpec6_crypto.c

2789

.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

1682

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1689

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1737

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1738

.chunksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1758

.chunksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1772

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1779

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1814

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1833

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1853

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1867

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1873

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1889

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1895

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1911

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1917

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1933

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1939

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1955

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1961

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1977

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1983

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

1999

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2005

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2022

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2028

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2044

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2050

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2067

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2073

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2089

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2095

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2112

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/caam/caamalg_qi2.c

2118

.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

109

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

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

113

iv_len = AES_BLOCK_SIZE;

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

173

.maxauthsize = AES_BLOCK_SIZE,

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

179

.cra_blocksize = AES_BLOCK_SIZE,

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

204

.ivsize = AES_BLOCK_SIZE,

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

165

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

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

166

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

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

178

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

71

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

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

220

.base.cra_blocksize = AES_BLOCK_SIZE,

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

260

.blocksize = AES_BLOCK_SIZE,

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

269

.blocksize = AES_BLOCK_SIZE,

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

270

.ivsize = AES_BLOCK_SIZE,

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

279

.ivsize = AES_BLOCK_SIZE,

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

83

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

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

90

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

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

92

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

1331

!IS_ALIGNED(cipherlen, AES_BLOCK_SIZE))

drivers/crypto/ccree/cc_aead.c

1445

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

drivers/crypto/ccree/cc_aead.c

1469

AES_BLOCK_SIZE, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1483

AES_BLOCK_SIZE + req_ctx->ccm_hdr_size, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1508

AES_BLOCK_SIZE, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1554

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

drivers/crypto/ccree/cc_aead.c

1555

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

drivers/crypto/ccree/cc_aead.c

1563

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

drivers/crypto/ccree/cc_aead.c

1585

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

drivers/crypto/ccree/cc_aead.c

1598

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

drivers/crypto/ccree/cc_aead.c

1635

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

drivers/crypto/ccree/cc_aead.c

1636

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

drivers/crypto/ccree/cc_aead.c

1650

AES_BLOCK_SIZE, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1680

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

drivers/crypto/ccree/cc_aead.c

1717

req_ctx->gcm_iv_inc2_dma_addr, AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

1747

AES_BLOCK_SIZE, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1755

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

drivers/crypto/ccree/cc_aead.c

1768

AES_BLOCK_SIZE, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1784

AES_BLOCK_SIZE, NS_BIT);

drivers/crypto/ccree/cc_aead.c

1846

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

drivers/crypto/ccree/cc_aead.c

1848

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

drivers/crypto/ccree/cc_aead.c

1946

areq_ctx->hw_iv_size = AES_BLOCK_SIZE;

drivers/crypto/ccree/cc_aead.c

2302

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2310

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2342

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2350

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2382

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2390

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2391

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2451

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2470

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2471

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2491

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2511

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2531

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_aead.c

2551

.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

1015

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1026

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1033

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1044

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1062

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1069

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1080

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1087

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1105

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1127

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1137

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1144

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1154

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

116

if (size >= AES_BLOCK_SIZE)

drivers/crypto/ccree/cc_cipher.c

1171

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1178

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1188

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1195

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

1212

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_cipher.c

125

if (IS_ALIGNED(size, AES_BLOCK_SIZE))

drivers/crypto/ccree/cc_hash.c

1774

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_hash.c

1786

.digestsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_hash.c

1787

.statesize = CC_STATE_SIZE(AES_BLOCK_SIZE),

drivers/crypto/ccree/cc_hash.c

1792

.inter_digestsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_hash.c

1799

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_hash.c

1811

.digestsize = AES_BLOCK_SIZE,

drivers/crypto/ccree/cc_hash.c

1812

.statesize = CC_STATE_SIZE(AES_BLOCK_SIZE),

drivers/crypto/ccree/cc_hash.c

1817

.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

1058

u8 input_iv[AES_BLOCK_SIZE];

drivers/crypto/inside-secure/safexcel_cipher.c

1311

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1327

ctx->blocksz = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_cipher.c

1341

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1349

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1401

ctx->blocksz = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_cipher.c

1659

ctx->blocksz = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_cipher.c

1686

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1695

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1722

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1731

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1758

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1767

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1794

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1803

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1830

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1839

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1866

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

1875

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

214

atoken->packet_length = AES_BLOCK_SIZE +

drivers/crypto/inside-secure/safexcel_cipher.c

2603

ctx->blocksz = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_cipher.c

2660

u32 hashkey[AES_BLOCK_SIZE >> 2];

drivers/crypto/inside-secure/safexcel_cipher.c

2682

memset(hashkey, 0, AES_BLOCK_SIZE);

drivers/crypto/inside-secure/safexcel_cipher.c

2686

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

drivers/crypto/inside-secure/safexcel_cipher.c

2694

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

drivers/crypto/inside-secure/safexcel_cipher.c

2697

memzero_explicit(hashkey, AES_BLOCK_SIZE);

drivers/crypto/inside-secure/safexcel_cipher.c

2779

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

drivers/crypto/inside-secure/safexcel_cipher.c

2784

ctx->state_sz = 2 * AES_BLOCK_SIZE + len;

drivers/crypto/inside-secure/safexcel_cipher.c

2803

ctx->state_sz = 3 * AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_cipher.c

2858

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

2859

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/inside-secure/safexcel_cipher.c

289

atoken->instructions = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_cipher.c

293

atoken->packet_length = AES_BLOCK_SIZE;

drivers/crypto/inside-secure/safexcel_cipher.c

3742

.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

1366

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1370

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1377

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1391

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1402

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1466

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1468

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1478

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1480

.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

421

rctx->ivsize = AES_BLOCK_SIZE;

drivers/crypto/qce/aead.c

732

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/qce/aead.c

733

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/qce/aead.c

741

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/qce/aead.c

742

.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/qce/aead.c

750

.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

366

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/qce/skcipher.c

375

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/qce/skcipher.c

376

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/qce/skcipher.c

385

.chunksize = AES_BLOCK_SIZE,

drivers/crypto/qce/skcipher.c

386

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/qce/skcipher.c

394

.blocksize = AES_BLOCK_SIZE,

drivers/crypto/qce/skcipher.c

395

.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

1230

if (req->cryptlen % AES_BLOCK_SIZE)

drivers/crypto/stm32/stm32-cryp.c

1241

if (req->cryptlen % AES_BLOCK_SIZE)

drivers/crypto/stm32/stm32-cryp.c

1252

if (req->cryptlen % AES_BLOCK_SIZE)

drivers/crypto/stm32/stm32-cryp.c

1263

if (req->cryptlen % AES_BLOCK_SIZE)

drivers/crypto/stm32/stm32-cryp.c

1433

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

1451

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

drivers/crypto/stm32/stm32-cryp.c

1455

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

drivers/crypto/stm32/stm32-cryp.c

1615

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

drivers/crypto/stm32/stm32-cryp.c

1643

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

drivers/crypto/stm32/stm32-cryp.c

1644

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

drivers/crypto/stm32/stm32-cryp.c

1681

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

drivers/crypto/stm32/stm32-cryp.c

1846

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

drivers/crypto/stm32/stm32-cryp.c

1847

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

drivers/crypto/stm32/stm32-cryp.c

2115

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

drivers/crypto/stm32/stm32-cryp.c

2129

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

drivers/crypto/stm32/stm32-cryp.c

2154

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

drivers/crypto/stm32/stm32-cryp.c

2283

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/stm32/stm32-cryp.c

2305

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/stm32/stm32-cryp.c

2313

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/stm32/stm32-cryp.c

2336

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/stm32/stm32-cryp.c

2445

.base.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/stm32/stm32-cryp.c

2467

.base.ivsize = AES_BLOCK_SIZE,

drivers/crypto/stm32/stm32-cryp.c

2468

.base.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/stm32/stm32-cryp.c

662

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

drivers/crypto/stm32/stm32-cryp.c

683

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

drivers/crypto/stm32/stm32-cryp.c

684

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

drivers/crypto/stm32/stm32-cryp.c

685

iv[AES_BLOCK_SIZE - 1] = 1;

drivers/crypto/stm32/stm32-cryp.c

689

memcpy(b0, iv, AES_BLOCK_SIZE);

drivers/crypto/stm32/stm32-cryp.c

698

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

drivers/crypto/stm32/stm32-cryp.c

699

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

drivers/crypto/talitos.c

2350

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2354

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2372

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2376

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2442

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2446

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2464

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2468

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2534

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2538

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2556

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2560

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2626

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2630

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2671

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2675

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2716

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2720

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2738

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2742

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2805

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2819

.base.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2824

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2840

.ivsize = AES_BLOCK_SIZE,

drivers/crypto/talitos.c

2856

.ivsize = AES_BLOCK_SIZE,

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

1487

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

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

1493

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

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

1522

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

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

1932

.maxauthsize = AES_BLOCK_SIZE,

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

1954

.maxauthsize = AES_BLOCK_SIZE,

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

1955

.ivsize = AES_BLOCK_SIZE,

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

1956

.chunksize = AES_BLOCK_SIZE,

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

1983

.halg.digestsize = AES_BLOCK_SIZE,

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

1990

.cra_blocksize = AES_BLOCK_SIZE,

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

217

data_count = rctx->len / AES_BLOCK_SIZE;

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

218

res_bits = (rctx->len % AES_BLOCK_SIZE) * 8;

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

280

if (rctx->len % AES_BLOCK_SIZE)

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

281

rctx->len += AES_BLOCK_SIZE - (rctx->len % AES_BLOCK_SIZE);

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

530

.ivsize = AES_BLOCK_SIZE,

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

536

.cra_blocksize = AES_BLOCK_SIZE,

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

557

.cra_blocksize = AES_BLOCK_SIZE,

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

573

.ivsize = AES_BLOCK_SIZE,

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

595

.ivsize = AES_BLOCK_SIZE,

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

601

.cra_blocksize = AES_BLOCK_SIZE,

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

617

data_count = (rctx->assoclen / AES_BLOCK_SIZE);

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

618

res_bits = (rctx->assoclen % AES_BLOCK_SIZE) * 8;

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

657

data_count = (rctx->cryptlen / AES_BLOCK_SIZE);

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

658

res_bits = (rctx->cryptlen % AES_BLOCK_SIZE) * 8;

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

864

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

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

905

cpuvaddr[i++] = (rctx->inbuf.size / AES_BLOCK_SIZE) - 1;

drivers/crypto/ti/dthev2-aes.c

102

#define AES_IV_SIZE AES_BLOCK_SIZE

drivers/crypto/ti/dthev2-aes.c

103

#define AES_BLOCK_WORDS (AES_BLOCK_SIZE / sizeof(u32))

drivers/crypto/ti/dthev2-aes.c

1117

memzero_explicit(rctx->padding, 2 * AES_BLOCK_SIZE);

drivers/crypto/ti/dthev2-aes.c

1221

.cra_alignmask = AES_BLOCK_SIZE - 1,

drivers/crypto/ti/dthev2-aes.c

1222

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/ti/dthev2-aes.c

1244

.cra_alignmask = AES_BLOCK_SIZE - 1,

drivers/crypto/ti/dthev2-aes.c

1245

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/ti/dthev2-aes.c

1261

.base.chunksize = AES_BLOCK_SIZE,

drivers/crypto/ti/dthev2-aes.c

1294

.cra_alignmask = AES_BLOCK_SIZE - 1,

drivers/crypto/ti/dthev2-aes.c

1295

.cra_blocksize = AES_BLOCK_SIZE,

drivers/crypto/ti/dthev2-aes.c

1310

.base.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ti/dthev2-aes.c

1313

.base.chunksize = AES_BLOCK_SIZE,

drivers/crypto/ti/dthev2-aes.c

1335

.base.maxauthsize = AES_BLOCK_SIZE,

drivers/crypto/ti/dthev2-aes.c

1338

.base.chunksize = AES_BLOCK_SIZE,

drivers/crypto/ti/dthev2-aes.c

381

if (ctx->aes_mode == DTHE_AES_CTR && req->cryptlen % AES_BLOCK_SIZE) {

drivers/crypto/ti/dthev2-aes.c

382

unsigned int pad_size = AES_BLOCK_SIZE - (req->cryptlen % AES_BLOCK_SIZE);

drivers/crypto/ti/dthev2-aes.c

398

memzero_explicit(pad_buf, AES_BLOCK_SIZE);

drivers/crypto/ti/dthev2-aes.c

500

if (ctx->aes_mode == DTHE_AES_CTR && req->cryptlen % AES_BLOCK_SIZE) {

drivers/crypto/ti/dthev2-aes.c

501

memzero_explicit(rctx->padding, AES_BLOCK_SIZE);

drivers/crypto/ti/dthev2-aes.c

532

if (req->cryptlen % AES_BLOCK_SIZE) {

drivers/crypto/ti/dthev2-aes.c

624

if (assoclen % AES_BLOCK_SIZE)

drivers/crypto/ti/dthev2-aes.c

633

if (assoclen % AES_BLOCK_SIZE) {

drivers/crypto/ti/dthev2-aes.c

634

unsigned int pad_len = AES_BLOCK_SIZE - (assoclen % AES_BLOCK_SIZE);

drivers/crypto/ti/dthev2-aes.c

680

if (cryptlen % AES_BLOCK_SIZE)

drivers/crypto/ti/dthev2-aes.c

691

if (cryptlen % AES_BLOCK_SIZE) {

drivers/crypto/ti/dthev2-aes.c

692

unsigned int pad_len = AES_BLOCK_SIZE - (cryptlen % AES_BLOCK_SIZE);

drivers/crypto/ti/dthev2-aes.c

873

u8 *src_crypt_padbuf = rctx->padding + AES_BLOCK_SIZE;

drivers/crypto/ti/dthev2-aes.c

874

u8 *dst_crypt_padbuf = rctx->padding + AES_BLOCK_SIZE;

drivers/crypto/ti/dthev2-aes.c

901

memset(src_assoc_padbuf, 0, AES_BLOCK_SIZE);

drivers/crypto/ti/dthev2-aes.c

902

memset(src_crypt_padbuf, 0, AES_BLOCK_SIZE);

drivers/crypto/ti/dthev2-aes.c

903

memset(dst_crypt_padbuf, 0, AES_BLOCK_SIZE);

drivers/crypto/ti/dthev2-aes.c

946

if (req->assoclen % AES_BLOCK_SIZE)

drivers/crypto/ti/dthev2-aes.c

947

assoclen += AES_BLOCK_SIZE - (req->assoclen % AES_BLOCK_SIZE);

drivers/crypto/ti/dthev2-aes.c

948

if (cryptlen % AES_BLOCK_SIZE)

drivers/crypto/ti/dthev2-aes.c

949

cryptlen += AES_BLOCK_SIZE - (cryptlen % AES_BLOCK_SIZE);

drivers/crypto/ti/dthev2-common.h

109

u8 padding[2 * AES_BLOCK_SIZE];

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/net/ethernet/marvell/octeontx2/nic/cn10k_macsec.c

60

static_assert(CN10K_MAX_HASH_LEN == 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

1343

for (i = 0; i < AES_BLOCK_SIZE - 1; i++)

drivers/staging/rtl8723bs/core/rtw_security.c

1346

pad[AES_BLOCK_SIZE - 1] <<= 1;

drivers/staging/rtl8723bs/core/rtw_security.c

1348

pad[AES_BLOCK_SIZE - 1] ^= 0x87;

drivers/staging/rtl8723bs/core/rtw_security.c

1368

u8 cbc[AES_BLOCK_SIZE], pad[AES_BLOCK_SIZE];

drivers/staging/rtl8723bs/core/rtw_security.c

1376

memset(cbc, 0, AES_BLOCK_SIZE);

drivers/staging/rtl8723bs/core/rtw_security.c

1387

while (left >= AES_BLOCK_SIZE) {

drivers/staging/rtl8723bs/core/rtw_security.c

1388

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

drivers/staging/rtl8723bs/core/rtw_security.c

1396

if (left > AES_BLOCK_SIZE)

drivers/staging/rtl8723bs/core/rtw_security.c

1398

left -= AES_BLOCK_SIZE;

drivers/staging/rtl8723bs/core/rtw_security.c

1401

memset(pad, 0, AES_BLOCK_SIZE);

drivers/staging/rtl8723bs/core/rtw_security.c

1418

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

drivers/ufs/host/ufs-exynos.c

1427

profile->max_dun_bytes_supported = AES_BLOCK_SIZE;

fs/crypto/keysetup_v1.c

244

derived_keysize % AES_BLOCK_SIZE != 0))

fs/crypto/keysetup_v1.c

249

for (unsigned int i = 0; i < derived_keysize; i += AES_BLOCK_SIZE)

include/crypto/aes-cbc-macs.h

110

void aes_cmac_final(struct aes_cmac_ctx *ctx, u8 out[at_least AES_BLOCK_SIZE]);

include/crypto/aes-cbc-macs.h

125

size_t data_len, u8 out[at_least AES_BLOCK_SIZE])

include/crypto/aes-cbc-macs.h

142

u8 h[AES_BLOCK_SIZE];

include/crypto/aes-cbc-macs.h

152

u8 out[at_least AES_BLOCK_SIZE]);

include/crypto/aes-cbc-macs.h

22

u8 b[AES_BLOCK_SIZE];

include/crypto/aes-cbc-macs.h

40

u8 h[AES_BLOCK_SIZE];

include/crypto/aes.h

377

void aes_encrypt(aes_encrypt_arg key, u8 out[at_least AES_BLOCK_SIZE],

include/crypto/aes.h

378

const u8 in[at_least AES_BLOCK_SIZE]);

include/crypto/aes.h

388

void aes_decrypt(const struct aes_key *key, u8 out[at_least AES_BLOCK_SIZE],

include/crypto/aes.h

389

const u8 in[at_least AES_BLOCK_SIZE]);

include/crypto/aes.h

397

int len, const u8 iv[AES_BLOCK_SIZE]);

include/crypto/aes.h

399

int len, const u8 iv[AES_BLOCK_SIZE]);

lib/crypto/aes.c

348

u8 out[AES_BLOCK_SIZE],

lib/crypto/aes.c

349

const u8 in[AES_BLOCK_SIZE])

lib/crypto/aes.c

406

u8 out[AES_BLOCK_SIZE],

lib/crypto/aes.c

407

const u8 in[AES_BLOCK_SIZE])

lib/crypto/aes.c

464

u8 out[AES_BLOCK_SIZE],

lib/crypto/aes.c

465

const u8 in[AES_BLOCK_SIZE])

lib/crypto/aes.c

471

u8 out[AES_BLOCK_SIZE],

lib/crypto/aes.c

472

const u8 in[AES_BLOCK_SIZE])

lib/crypto/aes.c

504

void aes_encrypt(aes_encrypt_arg key, u8 out[AES_BLOCK_SIZE],

lib/crypto/aes.c

505

const u8 in[AES_BLOCK_SIZE])

lib/crypto/aes.c

511

void aes_decrypt(const struct aes_key *key, u8 out[AES_BLOCK_SIZE],

lib/crypto/aes.c

512

const u8 in[AES_BLOCK_SIZE])

lib/crypto/aes.c

521

static bool aes_cbcmac_blocks_arch(u8 h[AES_BLOCK_SIZE],

lib/crypto/aes.c

531

static void aes_cbcmac_blocks(u8 h[AES_BLOCK_SIZE],

lib/crypto/aes.c

542

crypto_xor(h, data, AES_BLOCK_SIZE);

lib/crypto/aes.c

543

data += AES_BLOCK_SIZE;

lib/crypto/aes.c

546

crypto_xor(h, data, AES_BLOCK_SIZE);

lib/crypto/aes.c

567

memset(key->k_final[0].b, 0, AES_BLOCK_SIZE);

lib/crypto/aes.c

585

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

lib/crypto/aes.c

586

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

lib/crypto/aes.c

587

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

lib/crypto/aes.c

588

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

lib/crypto/aes.c

590

u8 new_aes_key[AES_BLOCK_SIZE];

lib/crypto/aes.c

592

static_assert(AES_BLOCK_SIZE == AES_KEYSIZE_128);

lib/crypto/aes.c

593

aes_prepareenckey(&key->aes, in_key, AES_BLOCK_SIZE);

lib/crypto/aes.c

597

aes_prepareenckey(&key->aes, new_aes_key, AES_BLOCK_SIZE);

lib/crypto/aes.c

598

memzero_explicit(new_aes_key, AES_BLOCK_SIZE);

lib/crypto/aes.c

609

size_t l = min(data_len, AES_BLOCK_SIZE - ctx->partial_len);

lib/crypto/aes.c

627

nblocks = data_len / AES_BLOCK_SIZE;

lib/crypto/aes.c

628

data_len %= AES_BLOCK_SIZE;

lib/crypto/aes.c

639

data += nblocks * AES_BLOCK_SIZE;

lib/crypto/aes.c

650

ctx->partial_len = AES_BLOCK_SIZE;

lib/crypto/aes.c

655

void aes_cmac_final(struct aes_cmac_ctx *ctx, u8 out[AES_BLOCK_SIZE])

lib/crypto/aes.c

657

if (ctx->partial_len == AES_BLOCK_SIZE) {

lib/crypto/aes.c

659

crypto_xor(ctx->h, ctx->key->k_final[0].b, AES_BLOCK_SIZE);

lib/crypto/aes.c

663

crypto_xor(ctx->h, ctx->key->k_final[1].b, AES_BLOCK_SIZE);

lib/crypto/aes.c

677

size_t l = min(data_len, AES_BLOCK_SIZE - ctx->partial_len);

lib/crypto/aes.c

683

if (ctx->partial_len < AES_BLOCK_SIZE)

lib/crypto/aes.c

688

nblocks = data_len / AES_BLOCK_SIZE;

lib/crypto/aes.c

689

data_len %= AES_BLOCK_SIZE;

lib/crypto/aes.c

696

data += nblocks * AES_BLOCK_SIZE;

lib/crypto/aes.c

703

void aes_cbcmac_final(struct aes_cbcmac_ctx *ctx, u8 out[AES_BLOCK_SIZE])

lib/crypto/aes.c

708

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

lib/crypto/aes.c

724

u8 mac[AES_BLOCK_SIZE];

lib/crypto/aescfb.c

23

int len, const u8 iv[AES_BLOCK_SIZE])

lib/crypto/aescfb.c

25

u8 ks[AES_BLOCK_SIZE];

lib/crypto/aescfb.c

30

crypto_xor_cpy(dst, src, ks, min(len, AES_BLOCK_SIZE));

lib/crypto/aescfb.c

33

dst += AES_BLOCK_SIZE;

lib/crypto/aescfb.c

34

src += AES_BLOCK_SIZE;

lib/crypto/aescfb.c

35

len -= AES_BLOCK_SIZE;

lib/crypto/aescfb.c

52

int len, const u8 iv[AES_BLOCK_SIZE])

lib/crypto/aescfb.c

54

u8 ks[2][AES_BLOCK_SIZE];

lib/crypto/aescfb.c

59

if (len > AES_BLOCK_SIZE)

lib/crypto/aescfb.c

67

crypto_xor_cpy(dst, src, ks[i], min(len, AES_BLOCK_SIZE));

lib/crypto/aescfb.c

69

dst += AES_BLOCK_SIZE;

lib/crypto/aescfb.c

70

src += AES_BLOCK_SIZE;

lib/crypto/aescfb.c

71

len -= AES_BLOCK_SIZE;

lib/crypto/aescfb.c

93

u8 iv[AES_BLOCK_SIZE] __nonstring;

lib/crypto/aesgcm.c

105

crypto_xor_cpy(dst, src, buf, min(len, AES_BLOCK_SIZE));

lib/crypto/aesgcm.c

107

dst += AES_BLOCK_SIZE;

lib/crypto/aesgcm.c

108

src += AES_BLOCK_SIZE;

lib/crypto/aesgcm.c

109

len -= AES_BLOCK_SIZE;

lib/crypto/aesgcm.c

164

u8 tagbuf[AES_BLOCK_SIZE];

lib/crypto/aesgcm.c

28

u8 h[AES_BLOCK_SIZE] = {};

lib/crypto/aesgcm.c

66

u8 ghash_out[AES_BLOCK_SIZE];

lib/crypto/aesgcm.c

67

u8 enc_ctr[AES_BLOCK_SIZE];

lib/crypto/aesgcm.c

678

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

162

u8 out[AES_BLOCK_SIZE],

lib/crypto/arm64/aes.h

163

const u8 in[AES_BLOCK_SIZE])

lib/crypto/arm64/aes.h

174

u8 out[AES_BLOCK_SIZE],

lib/crypto/arm64/aes.h

175

const u8 in[AES_BLOCK_SIZE])

lib/crypto/arm64/aes.h

18

u8 b[AES_BLOCK_SIZE];

lib/crypto/arm64/aes.h

189

static bool aes_cbcmac_blocks_arch(u8 h[AES_BLOCK_SIZE],

lib/crypto/arm64/aes.h

21

asmlinkage void __aes_arm64_encrypt(const u32 rk[], u8 out[AES_BLOCK_SIZE],

lib/crypto/arm64/aes.h

22

const u8 in[AES_BLOCK_SIZE], int rounds);

lib/crypto/arm64/aes.h

23

asmlinkage void __aes_arm64_decrypt(const u32 inv_rk[], u8 out[AES_BLOCK_SIZE],

lib/crypto/arm64/aes.h

24

const u8 in[AES_BLOCK_SIZE], int rounds);

lib/crypto/arm64/aes.h

25

asmlinkage void __aes_ce_encrypt(const u32 rk[], u8 out[AES_BLOCK_SIZE],

lib/crypto/arm64/aes.h

26

const u8 in[AES_BLOCK_SIZE], int rounds);

lib/crypto/arm64/aes.h

27

asmlinkage void __aes_ce_decrypt(const u32 inv_rk[], u8 out[AES_BLOCK_SIZE],

lib/crypto/arm64/aes.h

28

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/tests/aes-cmac-testvecs.h

178

static const u8 hash_testvec_consolidated[AES_BLOCK_SIZE] = {

lib/crypto/tests/aes-cmac-testvecs.h

6

u8 digest[AES_BLOCK_SIZE];

lib/crypto/tests/aes_cbc_macs_kunit.c

107

u8 mac[AES_BLOCK_SIZE];

lib/crypto/tests/aes_cbc_macs_kunit.c

110

KUNIT_ASSERT_MEMEQ(test, mac, testvecs[i].mac, AES_BLOCK_SIZE);

lib/crypto/tests/aes_cbc_macs_kunit.c

133

static const u8 expected_mac[AES_BLOCK_SIZE] = {

lib/crypto/tests/aes_cbc_macs_kunit.c

137

u8 actual_mac[AES_BLOCK_SIZE];

lib/crypto/tests/aes_cbc_macs_kunit.c

141

KUNIT_ASSERT_MEMEQ(test, actual_mac, expected_mac, AES_BLOCK_SIZE);

lib/crypto/tests/aes_cbc_macs_kunit.c

171

static const u8 expected_mac[AES_BLOCK_SIZE] = {

lib/crypto/tests/aes_cbc_macs_kunit.c

177

u8 actual_mac[AES_BLOCK_SIZE];

lib/crypto/tests/aes_cbc_macs_kunit.c

193

AES_BLOCK_SIZE);

lib/crypto/tests/aes_cbc_macs_kunit.c

203

AES_BLOCK_SIZE);

lib/crypto/tests/aes_cbc_macs_kunit.c

21

u8 out[AES_BLOCK_SIZE])

lib/crypto/tests/aes_cbc_macs_kunit.c

28

#define HASH_SIZE AES_BLOCK_SIZE

lib/crypto/tests/aes_cbc_macs_kunit.c

61

const u8 mac[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/ipv4/tcp_ao.c

40

.digest_size = AES_BLOCK_SIZE, /* same as AES_KEYSIZE_128 */

net/mac80211/aes_cmac.c

27

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

101

memcpy(out, v, AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

128

sg_init_one(dst, out + AES_BLOCK_SIZE, plain_len);

net/mac80211/fils_aead.c

149

u8 frame_iv[AES_BLOCK_SIZE], iv[AES_BLOCK_SIZE];

net/mac80211/fils_aead.c

150

u8 check[AES_BLOCK_SIZE];

net/mac80211/fils_aead.c

152

crypt_len = iv_c_len - AES_BLOCK_SIZE;

net/mac80211/fils_aead.c

158

memcpy(iv, iv_crypt, AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

159

memcpy(frame_iv, iv_crypt, AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

185

sg_init_one(src, iv_crypt + AES_BLOCK_SIZE, crypt_len);

net/mac80211/fils_aead.c

198

if (memcmp(check, frame_iv, AES_BLOCK_SIZE) != 0)

net/mac80211/fils_aead.c

249

skb_put(skb, AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

26

u8 d[AES_BLOCK_SIZE], tmp[AES_BLOCK_SIZE] = {};

net/mac80211/fils_aead.c

303

if (crypt_len < AES_BLOCK_SIZE) {

net/mac80211/fils_aead.c

317

*frame_len -= AES_BLOCK_SIZE;

net/mac80211/fils_aead.c

37

aes_cmac(&key, tmp, AES_BLOCK_SIZE, d);

net/mac80211/fils_aead.c

43

crypto_xor(d, tmp, AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

48

if (len[i] >= AES_BLOCK_SIZE) {

net/mac80211/fils_aead.c

51

aes_cmac_update(&ctx, addr[i], len[i] - AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

52

crypto_xor(d, addr[i] + len[i] - AES_BLOCK_SIZE,

net/mac80211/fils_aead.c

53

AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

62

aes_cmac_update(&ctx, d, AES_BLOCK_SIZE);

net/mac80211/fils_aead.c

75

u8 v[AES_BLOCK_SIZE];

net/mac80211/wpa.c

439

u8 b_0[AES_BLOCK_SIZE];

net/mac80211/wpa.c

570

u8 aad[2 * AES_BLOCK_SIZE];

net/mac80211/wpa.c

571

u8 b_0[AES_BLOCK_SIZE];

net/mac80211/wpa.c

655

u8 j_0[AES_BLOCK_SIZE];

net/mac80211/wpa.c

782

u8 aad[2 * AES_BLOCK_SIZE];

net/mac80211/wpa.c

783

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

314

buf = kmalloc(AES_BLOCK_SIZE, GFP_KERNEL);

security/keys/trusted-keys/trusted_dcp.c

320

memset(buf, 0x55, AES_BLOCK_SIZE);

security/keys/trusted-keys/trusted_dcp.c

326

if (memcmp(buf, bad, AES_BLOCK_SIZE) == 0) {