
/*
 * plat/gxb/sha2.c
 *
 * Copyright (C) 2015 Amlogic, Inc. All rights reserved.
*/
#include <common.h>
#include <linux/string.h>
#include <u-boot/sha256.h>
#include <asm/arch/secure_apb.h>


#ifndef __AP_DMA_H__
#define __AP_DMA_H__


typedef struct dma_dsc {
	union {
		uint32_t d32;
		struct {
		    unsigned length:17;
		    unsigned irq:1;
		    unsigned eoc:1;
		    unsigned loop:1;
		    unsigned mode:4;
		    unsigned begin:1;
		    unsigned end:1;
		    unsigned op_mode:2;
		    unsigned enc_sha_only:1;
		    unsigned block:1;
		    unsigned error:1;
		    unsigned owner:1;
		} b;
	} dsc_cfg;
	uint32_t src_addr;
	uint32_t tgt_addr;
} dma_dsc_t;

#endif /* __AP_DMA_H__ */

static sha2_ctx *cur_ctx;

static void hw_init(uint32_t is224)
{
	cur_ctx->digest_len = is224 ? 224 : 256;
	cur_ctx->tot_len = 0;
}

static void hw_update(const uint8_t *input, uint32_t ilen,
		      uint8_t *hash, uint8_t last_update)
{
	dma_dsc_t dsc;

	if (!last_update && (ilen % 64)) {
		serial_puts("Err:sha5\n");
		// sha2 usage problem
		return;
	}

	dsc.src_addr = (uint64_t)input;
	dsc.tgt_addr = (uint64_t)hash;
	dsc.dsc_cfg.d32 = 0;
	dsc.dsc_cfg.b.length = ilen;
	dsc.dsc_cfg.b.enc_sha_only = 1;
	dsc.dsc_cfg.b.mode = cur_ctx->digest_len == 224 ? 7 : 6;
	dsc.dsc_cfg.b.begin = cur_ctx->tot_len == 0; // first
	dsc.dsc_cfg.b.end = last_update;
	dsc.dsc_cfg.b.eoc = 1;
	dsc.dsc_cfg.b.owner = 1;

	*P_DMA_STS0 = 0xf;
	*P_DMA_T0 = (uint64_t)&dsc | 2;
	cur_ctx->tot_len += ilen;
	while (*P_DMA_STS0 == 0);

}

static void SHA2_HW_init(sha2_ctx *ctx, uint32_t digest_len)
{
	if (cur_ctx != NULL) {
		serial_puts("Err:sha4\n");
		// sha2 usage problem
		return;
	}
	cur_ctx = ctx;

	hw_init(digest_len == 224);

	ctx->len = 0;
}

static void SHA2_HW_update(sha2_ctx *ctx, const uint8_t *data, uint32_t len)
{
	unsigned int fill_len, data_len, rem_len,offset;

	if (cur_ctx != ctx) {
		serial_puts("Err:sha3\n");
		// sha2 usage problem
		return;
	}
	/* This method updates the hash for the input data in blocks, except the last
	 * partial|full block, which is saved in ctx->block.  The last partial|full
	 * block will be added to the hash in SHA2_final.
	 */
	data_len = len;
	offset = 0;
	/* fill saved block from beginning of input data */
	if (ctx->len) {
		fill_len = SHA256_BLOCK_SIZE - ctx->len;
		memcpy(&ctx->block[ctx->len], data, fill_len);
		data_len -= fill_len;
		offset = fill_len;
		ctx->len += fill_len;
	}
	if (ctx->len == SHA256_BLOCK_SIZE && data_len > 0) {
		/* saved block is full and is not last block, hash it */
		hw_update(ctx->block, SHA256_BLOCK_SIZE,ctx->buf, 0);
		ctx->len = 0;
	}
	if (data_len > SHA256_BLOCK_SIZE) {
		/* still have more than 1 block. hash up until last [partial|full] block */
		rem_len = data_len % SHA256_BLOCK_SIZE;
		if (rem_len == 0) {
			rem_len = SHA256_BLOCK_SIZE;
		}

		data_len -= rem_len;
		hw_update(&data[offset], data_len,ctx->buf, 0);
		offset += data_len;
	} else {
		rem_len = data_len;
	}

	if (rem_len) {
		/* save the remaining data */
		memcpy(ctx->block, &data[offset], rem_len);
		ctx->len = rem_len;
	}
}

static uint8_t *SHA2_HW_final(sha2_ctx *ctx)
{
	if (cur_ctx != ctx) {
		serial_puts("Err:sha1\n");
		// sha2 usage problem
		return ctx->buf;
	}
	if (ctx->len == 0 || ctx->len > SHA256_BLOCK_SIZE) {
		serial_puts("Err:sha2\n");
		// internal sha2 problem
		return ctx->buf;
	}
	hw_update(ctx->block, ctx->len,ctx->buf, 1);
	cur_ctx = NULL;
	return ctx->buf;
}
#if 0
void sha2(const uint8_t *input, unsigned int ilen, unsigned char output[32], unsigned int is224)
{
	sha2_ctx sha_ctx;
	int nOffset = 0;
	int nStep = (128<<10) - 64; //17bit length

	if (nStep > ilen)
		nStep = ilen;

	SHA2_HW_init(&sha_ctx,  is224 ? 224: 256);

	for (;nOffset< ilen;)
	{
		SHA2_HW_update(&sha_ctx, input+nOffset, nStep);
		nOffset+=nStep;
		if ((ilen - nOffset ) < nStep)
			nStep = ilen - nOffset;
	}

	SHA2_HW_final(&sha_ctx);

	memcpy(output,sha_ctx.buf,32);
}
#endif
static unsigned char dcache_flag=0,error_flag=0;

__attribute__((weak))
void sha256_starts(sha256_context * ctx)
{
	error_flag=0;

	if (dcache_status())
	{
	dcache_disable();
	SHA2_HW_init(ctx, 256);
	dcache_flag=1;
	}
	else
	{
	SHA2_HW_init(ctx, 256);
	dcache_flag=0;
	}
}

__attribute__((weak))
void sha256_update(sha256_context *ctx, const uint8_t *input, uint32_t length)
{
	if (dcache_status())
		{
		serial_puts("Err:sha2_update\n");
		error_flag=1;
		cur_ctx = NULL;
		return;
		}

	int nOffset = 0;
	int nStep = (128<<10) - 64; //17bit length

	if (nStep > length)
		nStep = length;

	for (;nOffset< length;)
	{
		SHA2_HW_update(ctx, input+nOffset, nStep);
		nOffset+=nStep;
		if ((length - nOffset ) < nStep)
			nStep = length - nOffset;
	}


}

__attribute__((weak))
void sha256_finish(sha256_context * ctx, uint8_t digest[SHA256_SUM_LEN])
{
	if (dcache_status())
		{
		serial_puts("Err:sha2_finish\n");
		error_flag=1;
		cur_ctx = NULL;
		return ;
		}

	SHA2_HW_final(ctx);

	if (dcache_flag == 1)
	{
	dcache_enable();
	}
	memcpy(digest,ctx->buf,32);
}

__attribute__((weak))
void sha256_csum_wd(const unsigned char *input, unsigned int ilen,
		unsigned char *output, unsigned int chunk_sz)
{

sha2_ctx sha_ctx;

sha256_starts(&sha_ctx);

sha256_update(&sha_ctx, input, ilen);
if (error_flag)
	return;


sha256_finish(&sha_ctx, output);
if (error_flag)
	return;

//memcpy(output,sha_ctx.buf,32);

}