| /* |
| * Copyright (C) 2017 C-SKY Microsystems Co., Ltd. All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /****************************************************************************** |
| * @file ck_sha.c |
| * @brief CSI Source File for SHA Driver |
| * @version V1.0 |
| * @date 02. June 2017 |
| ******************************************************************************/ |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdbool.h> |
| #include "csi_core.h" |
| #include "drv_sha.h" |
| #include "ck_sha_v1.h" |
| |
| #ifndef CONFIG_SHA_SUPPORT_MUL_THREAD |
| #define CONFIG_SHA_SUPPORT_MUL_THREAD 1 |
| #endif |
| |
| typedef struct { |
| uint32_t base; |
| uint32_t irq; |
| sha_event_cb_t cb; |
| sha_status_t status; |
| sha_mode_e mode; |
| sha_endian_mode_e endian; |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| uint32_t state[16]; |
| uint32_t sha_buffer[32]; |
| uint32_t total; |
| uint8_t first_cal; |
| #endif |
| } ck_sha_priv_t; |
| |
| #ifndef CONFIG_SHA_SUPPORT_MUL_THREAD |
| static ck_sha_priv_t sha_handle[CONFIG_SHA_NUM]; |
| #endif |
| bool finish_flag = 0; |
| |
| /* Driver Capabilities */ |
| static const sha_capabilities_t driver_capabilities = { |
| .sha1 = 1, /* sha1 mode */ |
| .sha224 = 1, /* sha224 mode */ |
| .sha256 = 1, /* sha256 mode */ |
| .sha384 = 1, /* sha384 mode */ |
| .sha512 = 1, /* sha512 mode */ |
| .sha512_224 = 1, /* sha512_224 mode */ |
| .sha512_256 = 1, /* sha512_256 mode */ |
| .endianmode = 1, /* endian mode */ |
| .interruptmode = 1 /* interrupt mode */ |
| }; |
| |
| #define ERR_SHA(errno) (CSI_DRV_ERRNO_SHA_BASE | errno) |
| #define SHA_NULL_PARAM_CHK(para) \ |
| do { \ |
| if (para == NULL) { \ |
| return ERR_SHA(EDRV_PARAMETER); \ |
| } \ |
| } while (0) |
| |
| extern int32_t target_get_sha(int32_t idx, uint32_t *base, uint32_t *irq); |
| extern int32_t target_get_sha_count(void); |
| // |
| // Functions |
| // |
| |
| ck_sha_reg_t *sha_reg = NULL; |
| |
| #ifndef CONFIG_SHA_SUPPORT_MUL_THREAD |
| static uint32_t sha_buffer[32]; |
| static uint32_t total[2] = {0x0}; |
| static uint8_t first_cal = 1; |
| #endif |
| static uint8_t sha_result[64] = {0x0}; |
| |
| static int32_t sha_set_mode(sha_mode_e mode) |
| { |
| sha_reg->SHA_MODE &= ~0x7; |
| sha_reg->SHA_MODE |= mode; |
| return 0; |
| } |
| |
| static void sha_set_source_message(uint32_t baseaddr) |
| { |
| sha_reg->SHA_BASEADDR = baseaddr; |
| } |
| |
| static void sha_set_dest_message(uint32_t destaddr) |
| { |
| sha_reg->SHA_DESTADDR = destaddr; |
| } |
| |
| static void sha_enable_without_count(void) |
| { |
| sha_reg->SHA_MODE |= 1<<25; |
| } |
| |
| static void sha_disable_without_count(void) |
| { |
| sha_reg->SHA_MODE &= ~(1<<25); |
| } |
| |
| static void sha_set_message_count(uint32_t count) |
| { |
| sha_reg->SHA_COUNTER0 = count; |
| sha_reg->SHA_COUNTER1 = 0; |
| } |
| |
| static int32_t sha_enable_initial(void) |
| { |
| sha_reg->SHA_MODE |= 1 << SHA_INIT_OFFSET; |
| return 0; |
| } |
| |
| static int32_t sha_disable_initial(void) |
| { |
| sha_reg->SHA_MODE &= ~(1 << SHA_INIT_OFFSET); |
| return 0; |
| } |
| |
| static int32_t sha_enable_calculate(void) |
| { |
| sha_reg->SHA_CON |= 1; |
| return 0; |
| } |
| |
| static int32_t sha_message_done(void) |
| { |
| while(sha_reg->SHA_CON & 0x1); |
| return 0; |
| } |
| |
| static void sha_new_encode(void) |
| { |
| sha_reg->SHA_INTSTATE = 0; |
| sha_reg->SHA_MODE = 0; |
| } |
| |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| static int32_t sha_restore_context(sha_handle_t handle, uint32_t *data) |
| { |
| uint32_t *result = (uint32_t *)&sha_reg->SHA_H0L; |
| |
| uint8_t i; |
| for (i = 0; i < 16; i++) { |
| result[i] = data[i]; |
| } |
| return 0; |
| } |
| |
| static int32_t sha_save_context(sha_handle_t handle, uint32_t *data) |
| { |
| uint32_t *result = (uint32_t *)&sha_reg->SHA_H0L; |
| |
| uint8_t i; |
| for (i = 0; i < 16; i++) { |
| data[i] = result[i]; |
| } |
| return 0; |
| } |
| #endif |
| |
| static inline void sha_reverse_order(uint8_t *pdata, int32_t length) |
| { |
| uint8_t input_data[length]; |
| uint8_t result[length]; |
| uint32_t tmp = 0; |
| int32_t i = 0; |
| memcpy((void *)input_data, (void *)pdata, length); |
| |
| for (i = 0; i < length; i++) { |
| tmp = i >> 2; |
| tmp = tmp << 3; |
| result[i] = input_data[tmp + 3 - i]; |
| } |
| |
| memcpy((void *)pdata, (void *)result, length); |
| } |
| |
| /** |
| \brief get sha handle count. |
| \return sha handle count |
| */ |
| int32_t csi_sha_get_instance_count(void) |
| { |
| return target_get_sha_count(); |
| } |
| |
| /** |
| \brief Initialize SHA Interface. 1. Initializes the resources needed for the SHA interface 2.registers event callback function |
| \param[in] idx must not exceed return value of csi_sha_get_instance_count() |
| \param[in] cb_event Pointer to \ref sha_event_cb_t |
| \return return sha handle if success |
| */ |
| sha_handle_t csi_sha_initialize(sha_handle_t handle, sha_event_cb_t cb_event) |
| { |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| uint32_t base = 0u; |
| uint32_t irq; |
| /* obtain the sha information */ |
| target_get_sha(0, &base, &irq); |
| ck_sha_priv_t *sha_priv = handle; |
| memset(sha_priv->state, 0, sizeof(sha_priv->state)); |
| sha_priv->total = 0; |
| sha_priv->first_cal = 1; |
| |
| #else |
| if (idx < 0 || idx >= CONFIG_SHA_NUM) { |
| return NULL; |
| } |
| |
| uint32_t base = 0u; |
| uint32_t irq; |
| /* obtain the sha information */ |
| int32_t real_idx = target_get_sha(idx, &base, &irq); |
| |
| if (real_idx != idx) { |
| return NULL; |
| } |
| ck_sha_priv_t *sha_priv = &sha_handle[idx]; |
| #endif |
| sha_priv->base = base; |
| sha_priv->irq = irq; |
| |
| /* initialize the sha context */ |
| sha_priv->cb = cb_event; |
| sha_priv->status.busy = 0; |
| |
| return (sha_handle_t)sha_priv; |
| } |
| |
| /** |
| \brief De-initialize SHA Interface. stops operation and releases the software resources used by the interface |
| \param[in] handle sha handle to operate. |
| \return error code |
| */ |
| int32_t csi_sha_uninitialize(sha_handle_t handle) |
| { |
| SHA_NULL_PARAM_CHK(handle); |
| |
| ck_sha_priv_t *sha_priv = handle; |
| sha_priv->cb = NULL; |
| |
| return 0; |
| } |
| |
| /** |
| \brief Get driver capabilities. |
| \param[in] handle sha handle to operate. |
| \return \ref sha_capabilities_t |
| */ |
| sha_capabilities_t csi_sha_get_capabilities(sha_handle_t handle) |
| { |
| return driver_capabilities; |
| } |
| |
| /** |
| \brief config sha mode. |
| \param[in] handle sha handle to operate. |
| \param[in] mode \ref sha_mode_e |
| \param[in] endian \ref sha_endian_mode_e |
| \return error code |
| */ |
| int32_t csi_sha_config(sha_handle_t handle, sha_mode_e mode, sha_endian_mode_e endian_mode) |
| { |
| SHA_NULL_PARAM_CHK(handle); |
| |
| ck_sha_priv_t *sha_priv = handle; |
| sha_reg = (ck_sha_reg_t *)(sha_priv->base); |
| |
| /* config the sha mode */ |
| switch (mode) { |
| case SHA_MODE_512_256: |
| case SHA_MODE_512_224: |
| return ERR_SHA(EDRV_UNSUPPORTED); |
| |
| case SHA_MODE_1: |
| case SHA_MODE_224: |
| case SHA_MODE_256: |
| case SHA_MODE_384: |
| case SHA_MODE_512: |
| sha_priv->mode = mode; |
| break; |
| |
| default: |
| return ERR_SHA(EDRV_PARAMETER); |
| } |
| |
| return 0; |
| } |
| |
| /** |
| \brief start the engine |
| \param[in] handle sha handle to operate. |
| \param[in] context Pointer to the sha context. |
| \return error code |
| */ |
| int32_t csi_sha_starts(sha_handle_t handle, void *context) |
| { |
| SHA_NULL_PARAM_CHK(handle); |
| |
| ck_sha_priv_t *sha_priv = handle; |
| sha_priv->status.busy = 1; |
| |
| sha_new_encode(); |
| sha_set_mode(sha_priv->mode); |
| |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| memset(sha_priv->sha_buffer, 0, sizeof(sha_priv->sha_buffer)); |
| memset(sha_priv->state, 0, sizeof(sha_priv->state)); |
| sha_priv->first_cal = 1; |
| sha_priv->total = 0; |
| #endif |
| |
| return 0; |
| } |
| |
| /** |
| \brief updata the engine |
| \param[in] handle sha handle to operate. |
| \param[in] context Pointer to the sha context. |
| \param[in] input Pointer to the Source data |
| \param[in] len the data len |
| \return error code |
| */ |
| int32_t csi_sha_update(sha_handle_t handle, void *context, const void *input, uint32_t len) |
| { |
| SHA_NULL_PARAM_CHK(handle); |
| SHA_NULL_PARAM_CHK(input); |
| if (len <= 0) { |
| return ERR_SHA(EDRV_PARAMETER); |
| } |
| |
| ck_sha_priv_t *sha_priv = handle; |
| sha_reg = (ck_sha_reg_t *)(sha_priv->base); |
| |
| uint8_t total_len_num; |
| uint32_t block_size; |
| if (sha_priv->mode < 4) { |
| block_size = 64; |
| total_len_num = 2; |
| } else { |
| block_size = 128; |
| total_len_num = 4; |
| } |
| |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| uint32_t *sha_buffer = sha_priv->sha_buffer; |
| uint8_t first_cal = sha_priv->first_cal; |
| sha_set_mode(sha_priv->mode); |
| uint32_t left = sha_priv->total & (block_size - 1); |
| uint32_t fill = block_size - left; |
| uint32_t total_length = sha_priv->total << 3; |
| uint32_t index = left >> 2; |
| |
| if (left & 0x3) { |
| index++; |
| } |
| sha_priv->total += len; |
| sha_priv->total &= 0xffffffff; |
| #else |
| uint32_t left = total[0] & (block_size - 1); |
| uint32_t fill = block_size - left; |
| uint32_t total_length = total[0] << 3; |
| uint32_t index = left >> 2; |
| |
| if (left & 0x3) { |
| index++; |
| } |
| total[0] += len; |
| total[0] &= 0xffffffff; |
| #endif |
| uint8_t *p = (uint8_t *)input; |
| /* when the text is not aligned by block and len > fill */ |
| if (left && len >= fill) { |
| if (finish_flag) { |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| memset(((uint8_t *)sha_buffer + left), 0x0, sizeof(sha_priv->sha_buffer) - left); |
| #else |
| memset(((uint8_t *)sha_buffer + left), 0x0, sizeof(sha_buffer) - left); |
| #endif |
| sha_buffer[index + total_len_num - 1] = total_length; |
| |
| sha_disable_without_count(); |
| sha_set_message_count(left << 3); |
| } else { |
| memcpy((void *)(((uint8_t *)sha_buffer) + left), p, fill); |
| p += fill; |
| |
| sha_enable_without_count(); |
| sha_set_message_count(block_size << 3); |
| } |
| |
| sha_set_source_message((uint32_t)sha_buffer); |
| sha_set_dest_message((uint32_t)sha_result); |
| if (first_cal == 0) { |
| sha_enable_initial(); |
| } else { |
| sha_disable_initial(); |
| } |
| |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| sha_restore_context(handle, (uint32_t *)sha_priv->state); |
| #endif |
| |
| sha_enable_calculate(); |
| sha_message_done(); |
| |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| sha_save_context(handle, (uint32_t *)sha_priv->state); |
| #endif |
| len -= fill; |
| left = 0; |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| sha_priv->first_cal = 0; |
| first_cal = 0; |
| #else |
| first_cal = 0; |
| #endif |
| } |
| |
| /* calculate the hash by block */ |
| while (len >= block_size) { |
| if (finish_flag) { |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| memset(sha_buffer, 0, sizeof(sha_priv->sha_buffer)); |
| #else |
| memset(sha_buffer, 0, sizeof(sha_buffer)); |
| #endif |
| sha_buffer[total_len_num - 1] = total_length; |
| |
| sha_set_source_message((uint32_t)sha_buffer); |
| sha_disable_without_count(); |
| sha_set_message_count(0); |
| } else { |
| memcpy(sha_buffer, p, block_size); |
| sha_set_source_message((uint32_t)sha_buffer); |
| sha_enable_without_count(); |
| sha_set_message_count(block_size << 3); |
| p += block_size; |
| } |
| sha_set_dest_message((uint32_t)sha_result); |
| if (first_cal == 0) { |
| sha_enable_initial(); |
| } else { |
| sha_disable_initial(); |
| } |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| sha_restore_context(handle, (uint32_t *)sha_priv->state); |
| #endif |
| |
| sha_enable_calculate(); |
| sha_message_done(); |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| sha_save_context(handle, (uint32_t *)sha_priv->state); |
| #endif |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| sha_priv->first_cal = 0; |
| first_cal = 0; |
| #else |
| first_cal = 0; |
| #endif |
| len -= block_size; |
| } |
| |
| /* when the text is not aligned by block and len < fill */ |
| if (len > 0) { |
| memcpy((void *)(((uint8_t *)sha_buffer) + left), p, len); |
| } |
| |
| sha_priv->status.busy = 0; |
| |
| return 0; |
| } |
| |
| /** |
| \brief finish the engine |
| \param[in] handle sha handle to operate. |
| \param[in] context Pointer to the sha context. |
| \param[out] output Pointer to the dest data |
| \return error code |
| */ |
| int32_t csi_sha_finish(sha_handle_t handle, void *context, void *output) |
| { |
| SHA_NULL_PARAM_CHK(handle); |
| SHA_NULL_PARAM_CHK(output); |
| |
| ck_sha_priv_t *sha_priv = handle; |
| uint32_t block_size; |
| if (sha_priv->mode < 4) { |
| block_size = 64; |
| } else { |
| block_size = 128; |
| } |
| |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| uint32_t last = sha_priv->total & (block_size - 1); |
| #else |
| uint32_t last = total[0] & (block_size - 1); |
| #endif |
| uint32_t padn = block_size - last; |
| |
| finish_flag = 1; |
| |
| csi_sha_update(handle, NULL, output, padn); |
| |
| uint8_t result_len = 20; |
| /* convert the data endian according the sha mode */ |
| if (sha_priv->mode == SHA_MODE_1) { |
| result_len = 20; |
| } else if (sha_priv->mode == SHA_MODE_224) { |
| result_len = 28; |
| } else if (sha_priv->mode == SHA_MODE_256) { |
| result_len = 32; |
| } else if (sha_priv->mode == SHA_MODE_512) { |
| result_len = 64; |
| } else if (sha_priv->mode == SHA_MODE_384) { |
| result_len = 48; |
| } |
| sha_reverse_order(sha_result, result_len); |
| memcpy((uint8_t*)output, sha_result, result_len); |
| |
| finish_flag = 0; |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| memset(sha_priv->sha_buffer, 0, sizeof(sha_priv->sha_buffer)); |
| sha_priv->first_cal = 1; |
| sha_priv->total = 0; |
| #else |
| memset(sha_buffer, 0, sizeof(sha_buffer)); |
| first_cal = 1; |
| total[0] = 0; |
| #endif |
| return 0; |
| } |
| |
| /** |
| \brief Get SHA status. |
| \param[in] handle sha handle to operate. |
| \return SHA status \ref sha_status_t |
| */ |
| sha_status_t csi_sha_get_status(sha_handle_t handle) |
| { |
| ck_sha_priv_t *sha_priv = handle; |
| return sha_priv->status; |
| } |