| /* |
| * 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_v2.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 |
| uint8_t state[64]; |
| uint8_t sha_buffer[128]; |
| uint32_t total; |
| uint32_t last_left; |
| #endif |
| } ck_sha_priv_t; |
| |
| #ifndef CONFIG_SHA_SUPPORT_MUL_THREAD |
| static ck_sha_priv_t sha_handle[CONFIG_SHA_NUM]; |
| #endif |
| static uint32_t g_sha_context[CONFIG_SHA_NUM]; |
| 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) |
| // |
| // Functions |
| // |
| |
| ck_sha_reg_t *sha_reg = NULL; |
| volatile static uint8_t sha_int_flag = 1; |
| |
| extern int32_t target_get_sha_count(void); |
| extern int32_t target_get_sha(int32_t idx, uint32_t *base, uint32_t *irq); |
| |
| static int32_t sha_set_mode(sha_mode_e mode) |
| { |
| sha_reg->SHA_CON &= ~0x7; |
| sha_reg->SHA_CON |= mode; |
| return 0; |
| } |
| |
| #ifndef CONFIG_SHA_BLOCK_MODE |
| static int32_t sha_enable_interrupt(void) |
| { |
| sha_reg->SHA_CON |= 1 << SHA_INT_ENABLE_OFFSET; |
| return 0; |
| } |
| |
| #ifndef CONFIG_SHA_SUPPORT_MUL_THREAD |
| static int32_t sha_disable_interrupt(void) |
| { |
| sha_reg->SHA_CON &= ~(1 << SHA_INT_ENABLE_OFFSET); |
| return 0; |
| } |
| #endif |
| #endif |
| |
| static void sha_clear_interrupt(void) |
| { |
| sha_reg->SHA_INTSTATE = 0; |
| } |
| |
| static int32_t sha_enable_initial(void) |
| { |
| sha_reg->SHA_CON |= 1 << SHA_INIT_OFFSET; |
| return 0; |
| } |
| |
| static int32_t sha_enable_calculate(void) |
| { |
| sha_reg->SHA_CON |= 1 << SHA_CAL_OFFSET; |
| return 0; |
| } |
| |
| #ifdef CONFIG_SHA_BLOCK_MODE |
| static int32_t sha_message_done(void) |
| { |
| while((sha_reg->SHA_CON & 0x40)); |
| return 0; |
| } |
| #endif |
| |
| static int32_t sha_select_endian_mode(sha_endian_mode_e mode) |
| { |
| sha_reg->SHA_CON &= ~(1 << SHA_ENDIAN_OFFSET); |
| sha_reg->SHA_CON |= mode << SHA_ENDIAN_OFFSET; |
| return 0; |
| } |
| |
| static int32_t sha_input_data(uint32_t *data, uint32_t length) |
| { |
| uint8_t i; |
| uint32_t tmp; |
| uint32_t *input_data = (uint32_t *) & (sha_reg->SHA_DATA1); |
| |
| for (i = 0; i < length; i++) { |
| memcpy(&tmp, (uint8_t *)(data+i), 4); |
| *(input_data + i) = tmp; |
| } |
| |
| return 0; |
| } |
| |
| static int32_t sha_get_data(sha_handle_t handle, uint32_t *data) |
| { |
| ck_sha_priv_t *sha_priv = handle; |
| |
| uint8_t len = 0; |
| uint8_t i; |
| uint32_t temp; |
| uint32_t *result = (uint32_t *)&sha_reg->SHA_H0L; |
| /* according to different mode to obtain the hash result */ |
| if (sha_priv->mode == SHA_MODE_1 || sha_priv->mode == SHA_MODE_224 || sha_priv->mode == SHA_MODE_256) { |
| if (sha_priv->mode == SHA_MODE_1) { |
| len = 5; |
| } else if (sha_priv->mode == SHA_MODE_224) { |
| len = 7; |
| } else if (sha_priv->mode == SHA_MODE_256) { |
| len = 8; |
| } |
| |
| for (i = 0; i < len; i++) { |
| temp = *(result + i); |
| memcpy(&data[i], &temp, 4); |
| } |
| } else { |
| if (sha_priv->mode == SHA_MODE_384) { |
| len = 6; |
| } else if (sha_priv->mode == SHA_MODE_512) { |
| len = 8; |
| } |
| |
| uint32_t *resulth = (uint32_t *)&sha_reg->SHA_H0H; |
| for (i = 0; i < len; i++) { |
| // data[i << 1] = *(resulth + i); |
| // data[(i << 1) + 1] = *(result + i); |
| temp = *(resulth + i); |
| memcpy(&data[i<<1], &temp, 4); |
| temp = *(result + i); |
| memcpy(&data[(i<<1)+1], &temp, 4); |
| } |
| } |
| |
| return 0; |
| } |
| |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| static int32_t sha_set_data(sha_handle_t handle, uint32_t *data) |
| { |
| ck_sha_priv_t *sha_priv = handle; |
| |
| uint8_t len = 0; |
| uint8_t i; |
| uint32_t *result = (uint32_t *)&sha_reg->SHA_H0L; |
| /* according to different mode to obtain the hash result */ |
| if (sha_priv->mode == SHA_MODE_1 || sha_priv->mode == SHA_MODE_224 || sha_priv->mode == SHA_MODE_256) { |
| if (sha_priv->mode == SHA_MODE_1) { |
| len = 5; |
| } else if (sha_priv->mode == SHA_MODE_224) { |
| len = 7; |
| } else if (sha_priv->mode == SHA_MODE_256) { |
| len = 8; |
| } |
| |
| for (i = 0; i < len; i++) { |
| *(result + i) = data[i]; |
| } |
| } else { |
| if (sha_priv->mode == SHA_MODE_384) { |
| len = 6; |
| } else if (sha_priv->mode == SHA_MODE_512) { |
| len = 8; |
| } |
| |
| uint32_t *resulth = (uint32_t *)&sha_reg->SHA_H0H; |
| for (i = 0; i < len; i++) { |
| *(resulth + i) = data[i << 1]; |
| *(result + i) = data[(i << 1) + 1] ; |
| } |
| } |
| |
| 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); |
| } |
| |
| void ck_sha_irqhandler(int32_t idx) |
| { |
| sha_int_flag = 0; |
| sha_clear_interrupt(); //clear sha interrupt |
| |
| #ifndef CONFIG_SHA_SUPPORT_MUL_THREAD |
| ck_sha_priv_t *sha_priv = &sha_handle[idx]; |
| #else |
| ck_sha_priv_t *sha_priv = (ck_sha_priv_t *)g_sha_context[idx]; |
| #endif |
| if (finish_flag != 0) { |
| if (sha_priv->cb != NULL) { |
| sha_priv->cb(SHA_EVENT_COMPLETE); //execute the callback function |
| } |
| } |
| } |
| |
| /** |
| \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->last_left = 0; |
| sha_priv->total = 0; |
| g_sha_context[0] = (uint32_t)handle; |
| #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; |
| |
| #ifndef CONFIG_SHA_BLOCK_MODE |
| drv_nvic_enable_irq(sha_priv->irq); |
| #endif |
| |
| 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; |
| |
| #ifndef CONFIG_SHA_SUPPORT_MUL_THREAD |
| #ifndef CONFIG_SHA_BLOCK_MODE |
| sha_disable_interrupt(); |
| drv_nvic_disable_irq(sha_priv->irq); |
| #endif |
| #endif |
| |
| 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); |
| } |
| |
| sha_set_mode(mode); |
| |
| /*config the sha endian mode */ |
| if (endian_mode == SHA_ENDIAN_MODE_LITTLE) { |
| sha_priv->endian = endian_mode; |
| sha_select_endian_mode(endian_mode); |
| } else if (endian_mode == SHA_ENDIAN_MODE_BIG) { |
| sha_priv->endian = endian_mode; |
| sha_select_endian_mode(endian_mode); |
| } else { |
| return ERR_SHA(EDRV_PARAMETER); |
| } |
| |
| #ifndef CONFIG_SHA_BLOCK_MODE |
| sha_enable_interrupt(); |
| #endif |
| |
| 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_enable_initial(); |
| sha_priv->status.busy = 1; |
| |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| sha_get_data(handle, (uint32_t *)sha_priv->state); |
| #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 |
| */ |
| #ifndef CONFIG_SHA_SUPPORT_MUL_THREAD |
| static uint8_t sha_buffer[128]; |
| static uint32_t total[2] = {0x0}; |
| static uint32_t last_left = 0; |
| #endif |
| 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); |
| } |
| g_sha_context[0] = (uint32_t)handle; |
| ck_sha_priv_t *sha_priv = handle; |
| sha_reg = (ck_sha_reg_t *)(sha_priv->base); |
| |
| uint32_t block_size; |
| if (sha_priv->mode < 4) { |
| block_size = 64; |
| } else { |
| block_size = 128; |
| } |
| |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| uint8_t *sha_buffer = sha_priv->sha_buffer; |
| uint32_t last_left = sha_priv->last_left; |
| 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; |
| |
| sha_priv->total += len; |
| sha_priv->total &= 0xffffffff; |
| uint32_t word_left = sha_priv->total & 0x3; |
| #else |
| uint32_t left = total[0] & (block_size - 1); |
| uint32_t fill = block_size - left; |
| uint32_t total_length = total[0] << 3; |
| |
| total[0] += len; |
| total[0] &= 0xffffffff; |
| uint32_t word_left = total[0] & 0x3; |
| #endif |
| uint8_t temp_data[4]; |
| uint32_t j; |
| if (finish_flag) { |
| /*calculate the final word*/ |
| for (j = 0; j < 4; j++) { |
| temp_data[j] = (total_length >> (8 * j)) & 0xff; |
| } |
| } |
| |
| uint8_t *p = (uint8_t *)input; |
| /* when the text is not aligned by block and len > fill */ |
| if (left && len >= fill) { |
| if (finish_flag) { |
| if (sha_priv->endian == SHA_ENDIAN_MODE_BIG) { |
| memset(&sha_buffer[left], 0x0, len); |
| sha_buffer[left] = 0x80; |
| for (j=0; j<4; j++) { |
| sha_buffer[left + len - 4 + j] = temp_data[3 - j]; |
| } |
| } else { |
| memset(&sha_buffer[left + 4 - last_left], 0x0, len - 4 + last_left); |
| sha_buffer[left - last_left + 3 - last_left] = 0x80; |
| for (j = 1; j < 4 - last_left; j++) { |
| sha_buffer[left - last_left + 3 - last_left - j] = 0x00; |
| } |
| for (j=0; j<4; j++) { |
| sha_buffer[left + len - 4 + j] = temp_data[j]; |
| } |
| } |
| } else { |
| if (last_left && sha_priv->endian == SHA_ENDIAN_MODE_LITTLE) { |
| uint32_t i; |
| for (i = 0; i < 4 - last_left; i++) { |
| *(sha_buffer + left + 3 - last_left - i) = *((uint8_t *)p + 3 - last_left - i); |
| } |
| |
| fill = fill - 4 + last_left; |
| p = (p + 4 - last_left); |
| } |
| else if (last_left) { |
| memcpy((void *)(sha_buffer + left + 4 - last_left), p, fill); |
| } else { |
| memcpy((void *)(sha_buffer + left), p, fill); |
| } |
| p += fill; |
| } |
| |
| /* set the input data */ |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| sha_set_data(handle, (uint32_t *)sha_priv->state); |
| #endif |
| sha_input_data((uint32_t *)sha_buffer, block_size >> 2); |
| sha_enable_calculate(); |
| |
| #ifdef CONFIG_SHA_BLOCK_MODE |
| sha_message_done(); |
| |
| #else |
| while (sha_int_flag); |
| |
| sha_int_flag = 1; |
| #endif |
| |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| sha_get_data(handle, (uint32_t *)sha_priv->state); |
| #endif |
| len -= fill; |
| left = 0; |
| } else { |
| 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 |
| if (sha_priv->endian == SHA_ENDIAN_MODE_BIG) { |
| sha_buffer[0] = 0x80; |
| for (j = 0; j < 4; j++) { |
| sha_buffer[block_size - 4 + j] = temp_data[3 - j]; |
| } |
| } else { |
| sha_buffer[3 - last_left] = 0x80; |
| for (j = 0; j < 4; j++) { |
| sha_buffer[block_size - 4 + j] = temp_data[j]; |
| } |
| } |
| } |
| } |
| |
| /* calculate the hash by block */ |
| while (len >= block_size) { |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| sha_set_data(handle, (uint32_t *)sha_priv->state); |
| #endif |
| if (finish_flag) { |
| if (fill == block_size) { |
| sha_input_data((uint32_t *)sha_buffer, block_size >> 2); |
| } else { |
| sha_input_data((uint32_t *)&sha_buffer[block_size], block_size >> 2); |
| } |
| } |
| else { |
| sha_input_data((uint32_t *)p, block_size >> 2); |
| p += block_size; |
| } |
| sha_enable_calculate(); |
| |
| #ifdef CONFIG_SHA_BLOCK_MODE |
| sha_message_done(); |
| |
| #else |
| while (sha_int_flag); |
| |
| sha_int_flag = 1; |
| #endif |
| |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| sha_get_data(handle, (uint32_t *)sha_priv->state); |
| #endif |
| len -= block_size; |
| } |
| |
| /* when the text is not aligned by block and len < fill */ |
| if (len > 0) { |
| if (sha_priv->endian == SHA_ENDIAN_MODE_BIG || word_left == 0) { |
| memcpy((void *)(sha_buffer + left), p, len); |
| } else { |
| memcpy((void *)(sha_buffer + left), p, len + 4 - word_left); |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| sha_priv->last_left = word_left; |
| #else |
| last_left = word_left; |
| #endif |
| } |
| } |
| |
| 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 |
| */ |
| //static uint32_t total_length; |
| 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; |
| uint8_t message_len; |
| if (sha_priv->mode < 4) { |
| block_size = 64; |
| message_len = 8; |
| } else { |
| block_size = 128; |
| message_len = 16; |
| } |
| |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| uint32_t last = sha_priv->total & (block_size - 1); |
| uint32_t padn = (last < (block_size - message_len)) ? (block_size - last) : (block_size + block_size - last); |
| |
| #else |
| uint32_t last = total[0] & (block_size - 1); |
| uint32_t padn = (last < (block_size - message_len)) ? (block_size - last) : (block_size + block_size - last); |
| |
| #endif |
| |
| finish_flag = 1; |
| |
| csi_sha_update(handle, NULL, output, padn); |
| |
| /* get the hash result */ |
| sha_get_data(handle, (uint32_t *)output); |
| |
| uint8_t *p = output; |
| /* convert the data endian according the sha mode */ |
| if (sha_priv->mode == SHA_MODE_1) { |
| sha_reverse_order(p, 20); |
| } else if (sha_priv->mode == SHA_MODE_224) { |
| sha_reverse_order(p, 28); |
| } else if (sha_priv->mode == SHA_MODE_256) { |
| sha_reverse_order(p, 32); |
| } else if (sha_priv->mode == SHA_MODE_512) { |
| sha_reverse_order(p, 64); |
| } else if (sha_priv->mode == SHA_MODE_384) { |
| sha_reverse_order(p, 48); |
| } |
| |
| #ifdef CONFIG_SHA_SUPPORT_MUL_THREAD |
| sha_priv->total = 0; |
| sha_priv->last_left = 0; |
| #else |
| total[0] = 0; |
| last_left = 0; |
| #endif |
| finish_flag = 0; |
| |
| 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; |
| } |
