static int md5_update(struct shash_desc *desc, const u8 *data, unsigned int len)
{
struct md5_state *mctx = shash_desc_ctx(desc);
const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
mctx->byte_count += len;
if (avail > len) {
memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
data, len);
return 0;
}
memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
data, avail);
md5_transform_helper(mctx);
data += avail;
len -= avail;
while (len >= sizeof(mctx->block)) {
memcpy(mctx->block, data, sizeof(mctx->block));
md5_transform_helper(mctx);
data += sizeof(mctx->block);
len -= sizeof(mctx->block);
}
memcpy(mctx->block, data, len);
return 0;
}
static void md5_update(void *ctx, const u8 *data, unsigned int len)
{
struct md5_ctx *mctx = ctx;
const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
mctx->byte_count += len;
if (avail > len) {
memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
data, len);
return;
}
memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
data, avail);
md5_transform_helper(mctx);
data += avail;
len -= avail;
while (len >= sizeof(mctx->block)) {
memcpy(mctx->block, data, sizeof(mctx->block));
md5_transform_helper(mctx);
data += sizeof(mctx->block);
len -= sizeof(mctx->block);
}
memcpy(mctx->block, data, len);
}
static void md5_update(void *ctx, const u8 *data, unsigned int len)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
struct md5_ctx *mctx = ctx;
const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#ifdef DEBUG_MD5
hexdump(mctx, sizeof(*mctx));
printk("md5_update running\n");
#endif //DEBUG_MD5
mctx->byte_count += len;
if(avail > len)
{
memcpy((char *) mctx->block + (sizeof(mctx->block) - avail), data, len);
return;
}
memcpy((char *) mctx->block + (sizeof(mctx->block) - avail), data, avail);
md5_transform_helper(mctx);
data += avail;
len -= avail;
while(len >= sizeof(mctx->block))
{
memcpy(mctx->block, data, sizeof(mctx->block));
md5_transform_helper(mctx);
data += sizeof(mctx->block);
len -= sizeof(mctx->block);
}
memcpy(mctx->block, data, len);
}
static void md5_final(void *ctx, u8 *out)
{
struct md5_ctx *mctx = ctx;
const unsigned int offset = mctx->byte_count & 0x3f;
char *p = (char *)mctx->block + offset;
int padding = 56 - (offset + 1);
*p++ = 0x80;
if (padding < 0) {
memset(p, 0x00, padding + sizeof (u64));
md5_transform_helper(mctx);
p = (char *)mctx->block;
padding = 56;
}
memset(p, 0, padding);
mctx->block[14] = mctx->byte_count << 3;
mctx->block[15] = mctx->byte_count >> 29;
le32_to_cpu_array(mctx->block, (sizeof(mctx->block) -
sizeof(u64)) / sizeof(u32));
md5_transform(mctx->hash, mctx->block);
cpu_to_le32_array(mctx->hash, sizeof(mctx->hash) / sizeof(u32));
memcpy(out, mctx->hash, sizeof(mctx->hash));
memset(mctx, 0, sizeof(*mctx));
}
static int
md5_update (struct digest_context *cx, const u8 *in, int size, int atomic)
{
md5_ctx_t *ctx = (md5_ctx_t *) cx->digest_info;
/* Space available in ctx->in (at least 1) */
const u32 avail = sizeof (ctx->in) - (ctx->byte_count & 0x3f);
/* Update byte count */
ctx->byte_count += size;
/* if in fits in ctx->in just copy and return */
if (avail > size) {
memcpy ((u8 *) ctx->in + (sizeof (ctx->in) - avail), in, size);
return 0;
}
/* First chunk is an odd size */
memcpy ((u8 *) ctx->in + (sizeof (ctx->in) - avail), in, avail);
md5_transform_helper (ctx);
in += avail;
size -= avail;
/* Process data in sizeof(ctx->in) chunks */
while (size >= sizeof (ctx->in)) {
memcpy (ctx->in, in, sizeof (ctx->in));
md5_transform_helper (ctx);
in += sizeof (ctx->in);
size -= sizeof (ctx->in);
}
/* assert (size < sizeof(ctx->in)); */
/* Handle any remaining bytes of data. */
memcpy (ctx->in, in, size);
return 0;
}
/*
* Final wrapup - pad to 64-byte boundary with the bit pattern
* 1 0* (64-bit count of bits processed, MSB-first)
*/
static inline void
md5_final (md5_ctx_t * ctx, u8 out[16])
{
/* Number of bytes in ctx->in */
const int offset = ctx->byte_count & 0x3f;
/* p points after last content byte in ctx->in */
u8 *p = (u8 *) ctx->in + offset;
/* Bytes of padding needed to make 56 bytes (-8..55) */
int padding = 56 - (offset + 1);
/* Set the first byte of padding to 0x80. There is always room. */
*p++ = 0x80;
if (padding < 0) { /* Padding forces an extra block */
memset (p, 0x00, padding + sizeof (u64));
md5_transform_helper (ctx);
p = (u8 *) ctx->in;
padding = 56;
}
/* pad remaining bytes w/ 0x00 */
memset (p, 0x00, padding);
/* Append length in bits and transform */
ctx->in[14] = ctx->byte_count << 3; /* low order word first */
ctx->in[15] = ctx->byte_count >> 29;
/* keep the appended bit-count words in host order! */
le32_to_cpu_array (ctx->in,
(sizeof (ctx->in) - sizeof (u64)) / sizeof (u32));
md5_transform (ctx->hash, ctx->in);
/* convert digest buf from host to LE byteorder */
cpu_to_le32_array (ctx->hash, sizeof (ctx->hash) / sizeof (u32));
/* copy to output buffer */
memcpy (out, ctx->hash, sizeof (ctx->hash));
/* wipe context */
memset (ctx, 0, sizeof (ctx));
}
/*! \fn static void md5_final(struct crypto_tfm *tfm, u8 *out)
* \ingroup IFX_MD5_FUNCTIONS
* \brief compute final md5 value
* \param tfm linux crypto algo transform
* \param out final md5 output value
*/
static int md5_final(struct shash_desc *desc, u8 *out)
{
struct md5_ctx *mctx = shash_desc_ctx(desc);
const unsigned int offset = mctx->byte_count & 0x3f;
char *p = (char *)mctx->block + offset;
int padding = 56 - (offset + 1);
volatile struct deu_hash_t *hashs = (struct deu_hash_t *) HASH_START;
unsigned long flag;
*p++ = 0x80;
if (padding < 0) {
memset(p, 0x00, padding + sizeof (u64));
md5_transform_helper(mctx);
p = (char *)mctx->block;
padding = 56;
}
memset(p, 0, padding);
mctx->block[14] = endian_swap(mctx->byte_count << 3);
mctx->block[15] = endian_swap(mctx->byte_count >> 29);
#if 0
le32_to_cpu_array(mctx->block, (sizeof(mctx->block) -
sizeof(u64)) / sizeof(u32));
#endif
md5_transform(mctx, mctx->hash, mctx->block);
CRTCL_SECT_START;
*((u32 *) out + 0) = endian_swap (hashs->D1R);
*((u32 *) out + 1) = endian_swap (hashs->D2R);
*((u32 *) out + 2) = endian_swap (hashs->D3R);
*((u32 *) out + 3) = endian_swap (hashs->D4R);
CRTCL_SECT_END;
// Wipe context
memset(mctx, 0, sizeof(*mctx));
return 0;
}
static void md5_final(void *ctx, u8 *out)
{
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
struct md5_ctx *mctx = ctx;
const unsigned int offset = mctx->byte_count & 0x3f;
char *p = (char *) mctx->block + offset;
int padding = 56 - (offset + 1);
unsigned long flag;
#ifndef ONLY_IN_MEM
volatile struct deu_hash_t *hashs = (struct hash_t *) HASH_START;
#else
unsigned char *prin = NULL;
struct deu_hash_t *hashs = NULL;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
hashs = (struct deu_hash_t *) kmalloc(sizeof(*hashs), GFP_KERNEL);
memset(hashs, 0, sizeof(*hashs));
prin = (unsigned char *) hashs;
#endif
#ifdef DEBUG_MD5
printk("md5_final running\n");
//hexdump(mctx,sizeof(*mctx));
printk("block before and after transform\n");
hexdump(mctx->block, sizeof(mctx->block));
#endif //DEBUG_MD5
*p++ = 0x80;
if(padding < 0)
{
memset(p, 0x00, padding + sizeof(u64));
md5_transform_helper(mctx);
p = (char *) mctx->block;
padding = 56;
}
memset(p, 0, padding);
#ifdef DEBUG_MD5
hexdump(&mctx->byte_count, sizeof(mctx->byte_count));
#endif //DEBUG_MD5
mctx->block[14] = cpu_to_le32(mctx->byte_count << 3);
mctx->block[15] = cpu_to_le32(mctx->byte_count >> 29);
#ifdef DEBUG_MD5
hexdump(mctx->block, sizeof(mctx->block));
#endif //DEBUG_MD5
//le32_to_cpu_array(mctx->block, (sizeof(mctx->block) -
// sizeof(u64)) / sizeof(u32));
md5_transform(mctx->hash, mctx->block);
local_irq_save(flag);
#ifdef CONFIG_CRYPTO_DEV_DANUBE_DMA
//wait for processing
while(hashs->controlr.BSY)
{
// this will not take long
}
#endif
*((u32 *) out + 0) = le32_to_cpu(hashs->D1R);
*((u32 *) out + 1) = le32_to_cpu(hashs->D2R);
*((u32 *) out + 2) = le32_to_cpu(hashs->D3R);
*((u32 *) out + 3) = le32_to_cpu(hashs->D4R);
hashs->controlr.SM = 0; // switch off again for next dma transfer
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#ifdef CONFIG_CRYPTO_DEV_DANUBE_DMA
struct dma_device_info *dma_device;
_ifx_deu_device *pDev = ifx_deu;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
dma_device = pDev->dma_device;
//if(dma_device) dma_device_release(dma_device);
if(dma_device)
{
dma_device_unregister(pDev->dma_device);
dma_device_release(pDev->dma_device);
}
#endif
//cpu_to_le32_array(mctx->hash, sizeof(mctx->hash) / sizeof(u32));
//memcpy(out, mctx->hash, sizeof(mctx->hash));
local_irq_restore(flag);
// Wipe context
memset(mctx, 0, sizeof(*mctx));
}
