| /*******************************************************************/ |
| /************************* File Description ************************/ |
| /*******************************************************************/ |
| /* File Name: $Workfile: hmx_uprade_system.c $ |
| * Version: $Revision: 1.0 $ |
| * Original Author: Yang Hyun Uk $ |
| * Current Author: $Author: huyang@humaxdigital.com $ |
| * Date: $Date: 2011.09.30 |
| * File Description: Humax Upgrade APIs |
| * Module: |
| * Remarks: |
| */ |
| |
| /** |
| * @defgroup UPGRADE_SYSTEM System APIs for Upgrade Module |
| * @ingroup UPGRADE |
| */ |
| |
| /** |
| * @author Hyunuk Yang(huyang@humaxdigital.com) |
| * @date 30 Sept 2011 |
| */ |
| |
| /** |
| * @note |
| * Copyright (C) 2011 Humax Corporation. All Rights Reserved. <br> |
| * This software is the confidential and proprietary information |
| * of Humax Corporation. You may not use or distribute this software |
| * except in compliance with the terms and conditions of any applicable license |
| * agreement in writing between Humax Corporation and you. |
| */ |
| |
| /*@{*/ |
| |
| /** |
| * @file hmx_upgrade_system.c |
| */ |
| |
| /*******************************************************************/ |
| /**************************** Header Files *************************/ |
| /*******************************************************************/ |
| /* Start Including Header Files */ |
| #include "hmx_upgrade_system.h" |
| /* End Including Headers */ |
| |
| |
| /*******************************************************************/ |
| /****************************** define *****************************/ |
| /*******************************************************************/ |
| |
| #ifdef TASK_DEBUG |
| #define PrintDebug(fmt, ...) printf (fmt, ## __VA_ARGS__) |
| #define PrintError(fmt, ...) printf (fmt, ## __VA_ARGS__) |
| #define PrintEnter(...) printf("(+)%s\n", __FUNCTION__) |
| #define PrintExit(...) printf("(-)%s\n", __FUNCTION__) |
| #else |
| #define PrintDebug(fmt, ...) while (0) ((int (*)(char *, ...)) 0) |
| #define PrintError(fmt, ...) printf (fmt, ## __VA_ARGS__) |
| #define PrintEnter(...) while (0) ((int (*)(char *, ...)) 0) |
| #define PrintExit(...) while (0) ((int (*)(char *, ...)) 0) |
| #endif |
| |
| |
| #define list_size(list) ((list)->curr_msg_count_) |
| |
| #define list_bitmap_size(list, i) ((list)->bitmap_count[(i)]) |
| |
| #define list_head(list, i) ((list)->head[i]) |
| |
| #define list_tail(list, i) ((list)->tail[i]) |
| |
| #define list_is_head(list, element) ((element) == (list)->head ? 1 : 0) |
| |
| #define list_is_tail(element) ((element)->next == NULL ? 1 : 0) |
| |
| #define list_data(element) ((element)->data) |
| |
| #define list_next(element) ((element)->next) |
| |
| #define HAPPY(a) (void)(a) |
| |
| /* End #define */ |
| |
| /*******************************************************************/ |
| /****************************** typedef ****************************/ |
| /*******************************************************************/ |
| /* Start typedef */ |
| /* End typedef */ |
| |
| |
| /*******************************************************************/ |
| /************************ global variables *************************/ |
| /*******************************************************************/ |
| /* Start global variable */ |
| |
| /* End global variable */ |
| |
| |
| /*******************************************************************/ |
| /************************ static variables *************************/ |
| /*******************************************************************/ |
| /* Start static variable */ |
| /* End static variable */ |
| |
| |
| /*******************************************************************/ |
| /************************ static funtions **************************/ |
| /*******************************************************************/ |
| |
| static int P_MSG_Check(struct HMX_MSG_queue *q, unsigned long q_id); |
| |
| |
| /* |
| list_find_highest_priority_bitmap |
| bitmap¿¡¼ °¡Àå ³ôÀº ¿ì¼±¼øÀ§¸¦ ã´Â´Ù. |
| */ |
| unsigned long list_find_highest_priority_bitmap(struct HMX_MSG_queue *list) |
| { |
| int i; |
| |
| for(i=MSG_PRIORITY_MAX-1; i>=0; i--) |
| { |
| if(list->bitmap[i] == 1) |
| return i; |
| } |
| |
| return 0; |
| } |
| |
| |
| |
| /* |
| print_list |
| HMX_MSG_queue ±¸Á¶Ã¼ Àüü¸¦ PrintÇÑ´Ù. |
| */ |
| void print_list(const struct HMX_MSG_queue *list) |
| { |
| struct HMX_MSG_element *element; |
| int *data, i, count; |
| |
| fprintf(stdout, "Msg Queue Current total size is %ld\n", list_size(list)); |
| |
| for(count=0; count<MSG_PRIORITY_MAX; count++) |
| { |
| i = 0; |
| |
| if( list->bitmap[count] != 0) |
| { |
| element = list_head(list, count); |
| |
| while (1) |
| { |
| data = list_data(element); |
| fprintf(stdout, "priority[%d] : qlist[%03d]=%03d\n", count, i, *data); |
| |
| i++; |
| |
| if (list_is_tail(element)) |
| break; |
| else |
| element = list_next(element); |
| } |
| } |
| } |
| } |
| |
| |
| |
| /* |
| list_set_bitmap |
| ¿ì¼±¼øÀ§¿¡ ÇØ´çÇÏ´Â ºñÆ®¸ÊÀ» set ÇÑ´Ù. |
| */ |
| void list_set_bitmap(struct HMX_MSG_queue *list, unsigned long prio) |
| { |
| list->bitmap[prio] = 1; |
| } |
| |
| |
| |
| /* |
| list_clear_bitmap |
| ¿ì¼±¼øÀ§¿¡ ÇØ´çÇÏ´Â ºñÆ®¸ÊÀ» clear ÇÑ´Ù. |
| */ |
| void list_clear_bitmap(struct HMX_MSG_queue *list, unsigned long prio) |
| { |
| list->bitmap[prio] = 0; |
| } |
| |
| |
| |
| |
| |
| |
| |
| /* |
| list_bitmap_count_increase |
| ÇØ´çÇÏ´Â ¿ì¼±¼øÀ§ÀÇ bitmap Count¸¦ Áõ°¡ ½ÃŲ´Ù. |
| */ |
| void list_bitmap_count_increase(struct HMX_MSG_queue *list, unsigned long prio) |
| { |
| list->bitmap_count[prio]++; |
| } |
| |
| |
| |
| /* |
| list_bitmap_count_decrease |
| ÇØ´çÇÏ´Â ¿ì¼±¼øÀ§ÀÇ bitmap Count¸¦ °¨¼Ò ½ÃŲ´Ù. |
| */ |
| void list_bitmap_count_decrease(struct HMX_MSG_queue *list, unsigned long prio) |
| { |
| list->bitmap_count[prio]--; |
| } |
| |
| |
| /* |
| list_mapping_task_priority_to_msgq |
| ŽºÅ© ¿ì¼±¼øÀ§¸¦ ±âÁØÀ¸·Î ¸Þ¼¼ÁöÅ¥ ¿ì¼±¼øÀ§¸¦ °áÁ¤ÇÑ´Ù. |
| */ |
| int list_find_msg_q_priority_from_task_priority(unsigned long *prio) |
| { |
| struct sched_param param; |
| int policy = 0; |
| int rc; |
| |
| rc = pthread_getschedparam( pthread_self(), &policy, ¶m); |
| if(rc != HMX_OK) |
| { |
| *prio = MSG_PRIORITY0; |
| return HMX_OK; |
| } |
| PrintDebug("policy = %d\n", policy); |
| PrintDebug("param.sched_priority = %d\n", param.sched_priority); |
| |
| switch(param.sched_priority) |
| { |
| case USER_PRIORITY0: |
| *prio = MSG_PRIORITY0; |
| break; |
| case USER_PRIORITY1: |
| *prio = MSG_PRIORITY1; |
| break; |
| case USER_PRIORITY2: |
| *prio = MSG_PRIORITY2; |
| break; |
| case USER_PRIORITY3: |
| *prio = MSG_PRIORITY3; |
| break; |
| case USER_PRIORITY4: |
| *prio = MSG_PRIORITY4; |
| break; |
| case USER_PRIORITY5: |
| *prio = MSG_PRIORITY5; |
| break; |
| case USER_PRIORITY6: |
| *prio = MSG_PRIORITY6; |
| break; |
| case USER_PRIORITY7: |
| *prio = MSG_PRIORITY7; |
| break; |
| case USER_PRIORITY8: |
| *prio = MSG_PRIORITY8; |
| break; |
| case USER_PRIORITY9: |
| *prio = MSG_PRIORITY9; |
| break; |
| case USER_PRIORITY10: |
| *prio = MSG_PRIORITY10; |
| break; |
| case USER_PRIORITY11: |
| *prio = MSG_PRIORITY11; |
| break; |
| case USER_PRIORITY12: |
| *prio = MSG_PRIORITY12; |
| break; |
| case USER_PRIORITY13: |
| *prio = MSG_PRIORITY13; |
| break; |
| case USER_PRIORITY14: |
| *prio = MSG_PRIORITY14; |
| break; |
| case USER_PRIORITY15: |
| *prio = MSG_PRIORITY15; |
| break; |
| default: |
| *prio = MSG_PRIORITY15; |
| break; |
| } |
| |
| return HMX_OK; |
| } |
| |
| |
| /* |
| q_insert_temp_tail_element |
| temp Qeue¿¡ element¸¦ ¿¬°á ÇÑ´Ù. |
| */ |
| void q_insert_temp_tail_element(struct HMX_MSG_queue *q, struct HMX_MSG_element *element) |
| { |
| if(q->temp_tail == NULL) |
| { |
| q->temp_head = element; |
| element->next = NULL; |
| element->prev = NULL; |
| q->temp_tail = element; |
| } |
| else |
| { |
| q->temp_tail->next = element; |
| element->next = NULL; |
| element->prev = q->temp_tail; |
| q->temp_tail = element; |
| } |
| } |
| |
| /* |
| q_remove_temp_tail_element |
| temp Qeue¿¡¼ ¸¶Áö¸· element¸¦ Á¦°ÅÇÏ¿© ³Ñ°ÜÁØ´Ù. |
| */ |
| void q_remove_temp_tail_element(struct HMX_MSG_queue *q, struct HMX_MSG_element **element) |
| { |
| PrintEnter(); |
| |
| *element = q->temp_tail; |
| |
| if(q->temp_head->next == NULL) //element 1°³ ³²Àº °æ¿ì. |
| { |
| q->temp_head = NULL; |
| q->temp_tail = NULL; |
| } |
| else |
| { |
| q->temp_tail->prev->next = NULL; |
| q->temp_tail = q->temp_tail->prev; |
| } |
| PrintExit(); |
| } |
| |
| /* |
| q_destory_temp_tail |
| temp QeueÀÇ element memory¸¦ ¼Ò¸ê½ÃŲ´Ù. |
| */ |
| void q_destory_temp_tail(struct HMX_MSG_queue *q) |
| { |
| struct HMX_MSG_element *q_element; |
| |
| PrintEnter(); |
| |
| do |
| { |
| q_element = q->temp_tail; |
| q->temp_tail = q->temp_tail->prev; |
| |
| |
| } while(q->temp_tail != NULL); |
| if (q->pPool) |
| { |
| free(q->pPool); |
| q->pPool = NULL; |
| } |
| if (q->pDataPool) |
| { |
| free(q->pDataPool); |
| q->pDataPool = NULL; |
| } |
| |
| PrintExit(); |
| } |
| |
| |
| /* |
| list_rem_next |
| element¿¡¼ data¸¦ »èÁ¦ÇÑ´Ù. |
| */ |
| int list_rem_next(struct HMX_MSG_queue *list, void *data, unsigned long size, unsigned char timeoutflag, struct timespec *timeo) |
| { |
| struct HMX_MSG_element *old_element; |
| unsigned long prio; |
| int rc = 0; |
| |
| PrintEnter(); |
| |
| list->reader_count_++; |
| |
| if ((list_size(list) == 0 || list->reader_count_ > 1) && 0 == rc) |
| { |
| if(TRUE == timeoutflag) |
| { |
| rc = pthread_cond_timedwait(&list->q_not_empty_, &list->q_lock_, timeo); |
| } |
| else |
| { |
| rc = pthread_cond_wait(&list->q_not_empty_, &list->q_lock_); |
| } |
| } |
| |
| list->reader_count_--; |
| |
| if(rc != 0) |
| { |
| PrintDebug("%s : rc[%d] !!\n", __FUNCTION__, rc); |
| return rc; |
| } |
| |
| prio = list_find_highest_priority_bitmap(list); |
| PrintDebug("list_find_highest_priority_bitmap : prio = %d\n", prio); |
| |
| memcpy(data, list->head[prio]->data, size); |
| old_element = list->head[prio]; |
| if(NULL == list->head[prio]->next) |
| { |
| list->head[prio] = NULL; |
| list->tail[prio] = NULL; |
| } |
| else |
| { |
| list->head[prio] = list->head[prio]->next; |
| } |
| |
| q_insert_temp_tail_element(list, old_element); |
| list->curr_msg_count_--; |
| list_bitmap_count_decrease(list, prio); |
| |
| if(list->bitmap_count[prio] == 0) |
| list_clear_bitmap(list, prio); |
| |
| if (list->writer_count_ > 0) |
| pthread_cond_signal(&list->q_not_full_); |
| |
| PrintExit(); |
| |
| return rc; |
| } |
| |
| |
| static void *thread_func_(void *arg) |
| { |
| struct HMX_TASK_arg *p = (struct HMX_TASK_arg *)arg; |
| int rc = 0; |
| |
| #if defined(CONFIG_DEBUG) |
| p->pid = getpid(); |
| p->tid = (long int)syscall(4222); |
| #endif |
| |
| pthread_mutex_lock(&p->lock_); |
| |
| while (p->start == 0 && 0 == rc) //wait signal |
| rc = pthread_cond_wait(&p->cond_, &p->lock_); |
| |
| pthread_mutex_unlock(&p->lock_); |
| |
| #if defined(CONFIG_DEBUG) |
| |
| p->thread_id = pthread_self(); |
| PrintDebug("[%s] task started...\n", p->name); |
| #endif |
| |
| (*p->start_func_)(p->arg_); |
| |
| return NULL; |
| } |
| |
| |
| /* |
| HMX_TASK_Create |
| ŽºÅ©¸¦ »ý¼ºÇÑ´Ù. |
| */ |
| int HMX_TASK_Create(void (*start_func)(void *), unsigned long prio,unsigned long stack_size, const char *name, void *arg, unsigned long *taskId, int IsJoinable) |
| { |
| int rc; |
| struct HMX_TASK *task; |
| pthread_attr_t thread_attr; |
| struct sched_param schParam; |
| unsigned char *pucDstStackAddr = NULL; |
| unsigned char *pucTaskStack; |
| |
| rc = pthread_attr_init (&thread_attr); |
| if (rc) { |
| return HMX_ERROR; |
| } |
| |
| rc = pthread_attr_setschedpolicy (&thread_attr, HMX_TASK_PTHREAD_DEFAULT_PRIO); |
| if (rc) { |
| return HMX_ERROR; |
| } |
| |
| pthread_attr_getschedparam(&thread_attr, &schParam); |
| schParam.sched_priority = prio; |
| rc = pthread_attr_setschedparam (&thread_attr, &schParam); |
| if (rc) { |
| return HMX_ERROR; |
| } |
| |
| if (stack_size < HMX_TASK_PTHREAD_STACK_MIN) |
| stack_size = HMX_TASK_PTHREAD_STACK_MIN; |
| |
| pucTaskStack = malloc(stack_size+HMX_TASK_STACK_OVERHEAD_SIZE+HMX_TASK_GUARD_SIZE); |
| if (pucTaskStack == NULL) |
| return HMX_ERROR; |
| memset(pucTaskStack, 0xA5, stack_size+HMX_TASK_STACK_OVERHEAD_SIZE+HMX_TASK_GUARD_SIZE ); |
| |
| PrintDebug("%s(%d) : pucTaskStack = %p, stack_size= %d\n", __FUNCTION__, __LINE__, pucTaskStack, stack_size); |
| rc = pthread_attr_setstack(&thread_attr, (void *)pucTaskStack, stack_size ); |
| if (rc) { |
| return HMX_ERROR; |
| } |
| |
| rc = pthread_attr_getstack(&thread_attr,(void *)&pucDstStackAddr, (size_t *)&stack_size ); |
| if (rc) { |
| return HMX_ERROR; |
| } |
| PrintDebug("%s(%d) : pucDstStackAddr = %p, stack_size= %d\n", __FUNCTION__, __LINE__, pucDstStackAddr, stack_size); |
| |
| if (IsJoinable == TRUE) |
| { |
| rc = pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLE); |
| } |
| else if(IsJoinable == FALSE) |
| { |
| rc = pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); |
| } |
| else |
| { |
| PrintError("%s(%s) : IsJoinable Parameter Error!!\n", __func__, __LINE__); |
| return HMX_ERROR; |
| } |
| |
| if (rc) { |
| PrintError ("%s(%d) : Failed to IsJoinable %s\n", __FUNCTION__, __LINE__, strerror (rc)); |
| return HMX_ERROR; |
| } |
| |
| if (task = (struct HMX_TASK *)malloc(sizeof(struct HMX_TASK)), NULL == task) { |
| *taskId = 0; |
| free(pucTaskStack); |
| return HMX_ERROR; |
| } |
| |
| task->targ_.start_func_ = start_func; |
| task->targ_.arg_ = arg; |
| task->targ_.priority_ = prio; |
| task->targ_.stackSize_ = stack_size; |
| task->targ_.IsJoinable = IsJoinable; |
| task->targ_.pucTaskStack = (unsigned long *)pucTaskStack; |
| task->targ_.pulStackStartAddress = (unsigned long *)pucDstStackAddr; |
| |
| pthread_mutex_init(&task->targ_.lock_, NULL); |
| pthread_cond_init(&task->targ_.cond_, NULL); |
| task->targ_.start = 0; |
| |
| strncpy(task->targ_.name, name, sizeof(task->targ_.name)-1); |
| |
| rc = pthread_create(&task->task_, &thread_attr, thread_func_, &task->targ_); |
| if (rc) { |
| free(pucTaskStack); |
| free(task); |
| *taskId = 0; |
| return HMX_ERROR; |
| } |
| |
| *taskId = (unsigned long)task; |
| |
| #if defined(CONFIG_TASK_PRIORITY) |
| pthread_setschedparam(task->task_, HMX_TASK_PTHREAD_DEFAULT_PRIO, &schParam); |
| #endif |
| |
| pthread_attr_destroy(&thread_attr); |
| PrintDebug("%s(%d) : s_ucTaskCount = %d\n", __func__, __LINE__, s_ucTaskCount); |
| return HMX_OK; |
| } |
| |
| int HMX_TASK_Start(unsigned long taskId) |
| { |
| struct HMX_TASK *task = (struct HMX_TASK *)taskId; |
| PrintEnter(); |
| |
| if(NULL == task) |
| { |
| PrintError("%s(%d) : task is NULL!!\n", __func__, __LINE__); |
| return HMX_ERROR; |
| } |
| |
| pthread_mutex_lock(&task->targ_.lock_); |
| if (task->targ_.start == 0) { |
| task->targ_.start = 1; |
| pthread_cond_signal(&task->targ_.cond_); |
| } |
| pthread_mutex_unlock(&task->targ_.lock_); |
| PrintExit(); |
| return HMX_OK; |
| } |
| |
| /* |
| HMX_TASK_Stop |
| Task¸¦ ¼öÇàµÈ ÀÌÈÄ¿¡ ÀÌ ÇÔ¼ö¸¦ È£ÃâÇصµ STOPÀº µÇÁö ¾Ê´Â´Ù. |
| ´ÜÁö count¸¸ 0À¸·Î ¸¸µç´Ù. |
| */ |
| int HMX_TASK_Stop(unsigned long taskId) |
| { |
| struct HMX_TASK *task = (struct HMX_TASK *)taskId; |
| |
| PrintEnter(); |
| |
| if (task == NULL) { |
| return HMX_OK; |
| } |
| |
| pthread_mutex_lock(&task->targ_.lock_); |
| if (task->targ_.start != 0) |
| task->targ_.start = 0; |
| pthread_mutex_unlock(&task->targ_.lock_); |
| |
| return HMX_OK; |
| } |
| |
| /* |
| sleep |
| ŽºÅ©¸¦ ÀáÀç¿î´Ù. |
| */ |
| int HMX_Sleep(unsigned long ultime) |
| { |
| struct timespec delay; |
| struct timespec rem; |
| int rc; |
| |
| if (ultime != 0) |
| { |
| HMX_TASK_CheckCallback(); |
| } |
| delay.tv_sec = ultime / 1000; |
| delay.tv_nsec = (ultime % 1000) * 1000000; |
| |
| for (;;) { |
| rc = nanosleep(&delay, &rem); |
| if (0 != rc) { |
| if (EINTR == errno) { |
| delay = rem; |
| continue; |
| } |
| return HMX_ERROR; |
| } |
| break; |
| } |
| |
| return HMX_OK; |
| } |
| |
| /* |
| HMX_TASK_Destroy |
| ŽºÅ©¸¦ ¼Ò¸êÇÑ´Ù. |
| */ |
| int HMX_TASK_Destroy(unsigned long taskId) |
| { |
| int rc; |
| struct HMX_TASK *task = (struct HMX_TASK *)taskId; |
| |
| if( taskId == (unsigned long)NULL ) |
| { |
| PrintDebug("%s(%d) taskId == NULL\n", __FUNCTION__, __LINE__); |
| return HMX_ERROR; |
| } |
| else |
| { |
| pthread_mutex_lock(&task->targ_.lock_); |
| if (task->targ_.start == 1) |
| { |
| task->targ_.start = 0; |
| } |
| rc = pthread_cancel(task->task_); |
| if (rc) |
| { |
| PrintError("[HMX_TASK_Destroy] warning : there is no thread in pthread taskId(%08X) pthreadId(%08X)\n", taskId, task->task_); |
| } |
| HMX_Sleep(1); |
| #if defined(CONFIG_THREAD_JOIN_TEMPORARY) |
| #else |
| if (task->targ_.IsJoinable) |
| #endif |
| pthread_join(task->task_, NULL); |
| |
| free(task->targ_.pucTaskStack); |
| pthread_mutex_unlock(&task->targ_.lock_); |
| } |
| |
| free(task); |
| |
| return HMX_OK; |
| } |
| |
| /* |
| HMX_TASK_SetCurrentPriority |
| »õ·Î¿î ¿ì¼±¼øÀ§¸¦ ¼¼ÆÃÇÑ´Ù. |
| */ |
| int HMX_TASK_SetCurrentPriority(unsigned long taskId, unsigned long newpriority) |
| { |
| int rc; |
| int policy; |
| struct HMX_TASK *task = (struct HMX_TASK *)taskId; |
| struct sched_param schParam; |
| |
| if (task == NULL) |
| { |
| return HMX_ERROR; |
| } |
| |
| rc = pthread_getschedparam(task->task_, &policy, &schParam); |
| if (schParam.sched_priority == (int)newpriority) |
| { |
| return HMX_OK; |
| } |
| |
| schParam.sched_priority = newpriority; |
| |
| pthread_mutex_lock(&task->targ_.lock_); |
| rc = pthread_setschedparam(task->task_, policy, &schParam); |
| pthread_mutex_unlock(&task->targ_.lock_); |
| |
| if (rc) { |
| return HMX_ERROR; |
| } |
| |
| return HMX_OK; |
| } |
| |
| |
| |
| /* |
| list_init |
| HMX_MSG_queue ±¸Á¶Ã¼¸¦ ÃʱâÈ ÇÑ´Ù. |
| */ |
| void list_init(struct HMX_MSG_queue *list, unsigned long ulSize, unsigned long ulCount, unsigned char ucSuspendType) |
| { |
| int i; |
| |
| list->curr_msg_count_ = 0; |
| list->msg_size_ = ulSize; |
| list->msg_count_ = ulCount; |
| list->writer_count_ = 0; |
| list->reader_count_ = 0; |
| list->suspend_type_ = ucSuspendType; |
| pthread_mutex_init(&list->q_lock_, NULL); |
| pthread_cond_init(&list->q_not_empty_, NULL); |
| pthread_cond_init(&list->q_not_full_, NULL); |
| |
| list->temp_head = NULL; |
| list->temp_tail = NULL; |
| |
| for(i=0; i<MSG_PRIORITY_MAX; i++) |
| { |
| list->head[i] = NULL; |
| list->tail[i] = NULL; |
| list->bitmap_count[i] = 0; |
| list->bitmap[i] = 0; |
| } |
| |
| #ifdef HMX_MSG_DEBUG |
| list->sendTick = 0; |
| list->receiveTick = 0; |
| list->lastSendTick = 0; |
| list->lastReceiveTick = 0; |
| #endif |
| return; |
| } |
| |
| |
| |
| /* |
| list_destroy |
| HMX_MSG_queue ±¸Á¶Ã¼¸¦ ¼Ò¸ê½ÃŲ´Ù. |
| */ |
| void list_destroy(struct HMX_MSG_queue *list) |
| { |
| void *data; |
| |
| data = (char *)malloc(list->msg_size_); |
| |
| while (list_size(list) > 0) |
| { |
| if ( list_rem_next(list, (void *)data, list->msg_size_, FALSE, FALSE) != 0 ) |
| { |
| PrintError("%s : list_rem_next Error!!\n", __func__); |
| } |
| } |
| |
| free(data); |
| return; |
| } |
| |
| |
| |
| /* |
| list_ins_next |
| element¿¡ data¸¦ Ãß°¡ÇÑ´Ù. |
| */ |
| int list_ins_next(struct HMX_MSG_queue *list, unsigned long prio, const void *data, unsigned long size, unsigned char timeoutflag, struct timespec *timeo) |
| { |
| struct HMX_MSG_element *new_element; |
| int rc = 0; |
| |
| PrintEnter(); |
| |
| list->writer_count_++; |
| |
| while (list->msg_count_ == list->curr_msg_count_ && 0 == rc) |
| { |
| if(TRUE == timeoutflag) |
| { |
| rc = pthread_cond_timedwait(&list->q_not_full_, &list->q_lock_, timeo); |
| } |
| else |
| { |
| rc = pthread_cond_wait(&list->q_not_full_, &list->q_lock_); |
| } |
| } |
| |
| list->writer_count_--; |
| |
| if(rc != 0) |
| { |
| PrintDebug("%s : rc[%d] !!\n", __FUNCTION__, rc); |
| return rc; |
| } |
| |
| q_remove_temp_tail_element(list, &new_element); |
| |
| memcpy(new_element->data, data, size); |
| |
| if(list->tail[prio] == NULL) |
| { |
| list->head[prio] = new_element; |
| new_element->next = NULL; |
| new_element->prev = NULL; |
| list->tail[prio] = new_element; |
| } |
| else |
| { |
| list->tail[prio]->next = new_element; |
| new_element->next = NULL; |
| new_element->prev = list->tail[prio]; |
| list->tail[prio] = new_element; |
| } |
| |
| list->curr_msg_count_++; |
| list_bitmap_count_increase(list, prio); |
| list_set_bitmap(list, prio); |
| |
| if (list->reader_count_ > 0) |
| pthread_cond_signal(&list->q_not_empty_); |
| |
| PrintExit(); |
| return HMX_OK; |
| } |
| |
| |
| |
| |
| /* |
| HMX_MSG_Init |
| ¸Þ¼¼Áö Å¥¸¦ ÃʱâÈ ÇÑ´Ù. |
| */ |
| int HMX_MSG_Init(void) |
| { |
| #if defined(HMX_MSG_DEBUG) |
| TAILQ_INIT(&msg_q_list_head); |
| #endif |
| return HMX_OK; |
| } |
| |
| |
| /* |
| HMX_MSG_Create |
| ¸Þ¼¼Áö Å¥¸¦ »ý¼ºÇÑ´Ù. |
| */ |
| int HMX_MSG_Create(unsigned long q_count, unsigned long msg_size, |
| const char *q_name, unsigned long *q_id, HMX_SUSPENDTYPE suspendType) |
| { |
| struct HMX_MSG_queue *q; |
| struct HMX_MSG_element *q_element; |
| unsigned long i; |
| struct HMX_MSG_element *q_element_pool; |
| unsigned char *data_pool; |
| HAPPY(q_name); |
| |
| PrintEnter(); |
| |
| if(suspendType >= HMX_SUSPENDTYPE_MAX) |
| { |
| PrintError("%s[%d] : ulSuspendType %d Error\n", __FUNCTION__, __LINE__, suspendType); |
| return HMX_ERROR; |
| } |
| |
| if((q = (struct HMX_MSG_queue *)malloc(sizeof(struct HMX_MSG_queue))) == NULL) |
| { |
| PrintError("%s[%d] : malloc Error\n", __FUNCTION__, __LINE__); |
| return HMX_ERROR; |
| } |
| |
| memset(q, 0, sizeof(struct HMX_MSG_queue)); |
| |
| list_init(q, msg_size, q_count, suspendType); |
| q_element_pool = (struct HMX_MSG_element *)malloc(sizeof(struct HMX_MSG_element)*q_count); |
| data_pool = (unsigned char *)malloc(msg_size*q_count); |
| for(i=0; i<q_count; i++) |
| { |
| q_element = &q_element_pool[i]; |
| q_element->data = &data_pool[i*msg_size]; |
| q_insert_temp_tail_element(q, q_element); |
| } |
| q->pDataPool = data_pool; |
| q->pPool = q_element_pool; |
| |
| *q_id = (unsigned long)q; |
| |
| #if defined(HMX_MSG_DEBUG) |
| TAILQ_INSERT_TAIL(&msg_q_list_head, q, entries); |
| #endif |
| #if defined(CONFIG_DEBUG) |
| if (q_name) |
| strncpy(q->name, q_name, sizeof(q->name)-1); |
| else |
| q->name[0] = 0; |
| #endif |
| PrintExit(); |
| |
| return HMX_OK; |
| } |
| |
| |
| /* |
| HMX_MSG_Destroy |
| ¸Þ¼¼ÁöÅ¥¸¦ ¼Ò¸ê½ÃŲ´Ù. |
| */ |
| int HMX_MSG_Destroy(unsigned long q_id) |
| { |
| struct HMX_MSG_queue *q; |
| |
| PrintEnter(); |
| |
| q = (struct HMX_MSG_queue *)q_id; |
| |
| if(q == NULL) |
| { |
| return HMX_ERROR; |
| } |
| |
| pthread_cond_destroy(&q->q_not_full_); |
| pthread_cond_destroy(&q->q_not_empty_); |
| pthread_mutex_destroy(&q->q_lock_); |
| |
| list_destroy(q); |
| q_destory_temp_tail(q); |
| |
| #if defined(HMX_MSG_DEBUG) |
| TAILQ_REMOVE(&msg_q_list_head, q, entries); |
| #endif |
| |
| if(q != NULL) |
| { |
| free(q); |
| } |
| |
| PrintExit(); |
| |
| return HMX_OK; |
| } |
| |
| int HMX_MSG_Clear(unsigned long q_id) |
| { |
| struct HMX_MSG_queue *q; |
| int rc = HMX_OK; |
| // struct timespec cur_time; |
| long long exp_nsec; |
| struct timespec timeo, cur_time; |
| unsigned long size; |
| void *pBuf; |
| |
| |
| PrintEnter(); |
| |
| q = (struct HMX_MSG_queue *)q_id; |
| |
| size = q->msg_size_; |
| pBuf = malloc(size); |
| if (pBuf == NULL) |
| return HMX_ERROR; |
| |
| (void)pthread_mutex_lock(&q->q_lock_); |
| do |
| { |
| |
| clock_gettime(CLOCK_REALTIME, &cur_time); |
| exp_nsec = (long long)cur_time.tv_sec * (long long)1000 * (long long)1000 * (long long)1000 + (long long)cur_time.tv_nsec; |
| timeo.tv_sec = exp_nsec / (1000 * 1000 * 1000); |
| timeo.tv_nsec = exp_nsec % (1000 * 1000 * 1000); |
| |
| rc = list_rem_next(q, pBuf, size, TRUE, &timeo); |
| if(HMX_OK != rc) |
| { |
| if(ETIMEDOUT == rc) |
| { |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| free(pBuf); |
| return HMX_OK; |
| } |
| } |
| }while (1); |
| #ifdef DEBUG_MSG_LIST_PRINT |
| print_list(q); |
| #endif |
| |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| |
| free(pBuf); |
| PrintExit(); |
| return HMX_OK; |
| } |
| |
| |
| /* |
| HMX_MSG_Send |
| ¸Þ¼¼Áö¸¦ º¸³½´Ù. |
| */ |
| int HMX_MSG_Send(unsigned long q_id, const void *msg, unsigned long size) |
| { |
| struct HMX_MSG_queue *q; |
| int rc = HMX_OK; |
| unsigned long prio; |
| |
| PrintEnter(); |
| |
| q = (struct HMX_MSG_queue *)q_id; |
| |
| if(size > q->msg_size_) |
| { |
| PrintError("%s[%d] : size %ld Error\n", __FUNCTION__, __LINE__, size); |
| return HMX_ERROR; |
| } |
| |
| HMX_TASK_CheckCallback(); |
| |
| rc = P_MSG_Check(q, q_id); |
| if (HMX_OK != rc) |
| { |
| #if defined(CONFIG_DEBUG) |
| PrintError("%s(%d) : P_MSG_Check : HMX_MSG_FULL!! queue name (%s)\n", __func__, __LINE__, q->name); |
| #endif |
| return rc; |
| } |
| |
| if(HMX_SUSPENDTYPE_PRIORITY == q->suspend_type_) |
| { |
| rc = list_find_msg_q_priority_from_task_priority(&prio); |
| if(rc != HMX_OK) |
| { |
| prio = MSG_PRIORITY0; |
| } |
| } |
| else |
| { |
| prio = MSG_PRIORITY0; |
| } |
| |
| (void)pthread_mutex_lock(&q->q_lock_); |
| |
| rc = list_ins_next(q, prio, msg, size, FALSE, NULL); |
| |
| if(HMX_OK != rc) |
| { |
| PrintError("%s : list_ins_next() rc[%d] Error!!\n", __FUNCTION__, rc); |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| return rc; |
| } |
| |
| #ifdef DEBUG_MSG_LIST_PRINT |
| print_list(q); |
| #endif |
| |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| |
| #ifdef HMX_MSG_DEBUG |
| q->lastSendTick = VK_TIMER_GetSystemTick(); |
| #endif |
| |
| PrintExit(); |
| |
| return HMX_OK; |
| } |
| |
| |
| |
| /* |
| HMX_MSG_SendTimeout |
| ¸Þ¼¼Áö¸¦ Timeout³»¿¡ º¸³½´Ù. |
| */ |
| int HMX_MSG_SendTimeout(unsigned long q_id, const void *msg, unsigned long size, unsigned long timeout) |
| { |
| struct HMX_MSG_queue *q; |
| int rc = HMX_OK; |
| unsigned long prio = 0; |
| struct timespec timeo; |
| struct timespec cur_time; |
| long long exp_nsec; |
| |
| PrintEnter(); |
| |
| if (timeout != 0) |
| { |
| // HMX_TASK_CheckCallback(); |
| } |
| if (timeout == 0xFFFFFFFF) |
| { |
| return HMX_MSG_Send(q_id, msg, size); |
| } |
| |
| q = (struct HMX_MSG_queue *)q_id; |
| |
| if(size > q->msg_size_) |
| { |
| PrintError("%s[%d] : size %ld Error\n", __FUNCTION__, __LINE__, size); |
| return HMX_ERROR; |
| } |
| |
| rc = P_MSG_Check(q, q_id); |
| if (HMX_OK != rc) |
| { |
| #if defined(CONFIG_DEBUG) |
| PrintError("%s(%d) : P_MSG_Check : HMX_MSG_FULL!! queue name : %s\n", __func__, __LINE__, q->name); |
| #endif |
| return rc; |
| } |
| |
| if(HMX_SUSPENDTYPE_PRIORITY == q->suspend_type_) |
| { |
| rc = list_find_msg_q_priority_from_task_priority(&prio); |
| if(rc != HMX_OK) |
| { |
| prio = MSG_PRIORITY0; |
| } |
| } |
| else |
| { |
| prio = MSG_PRIORITY0; |
| } |
| |
| clock_gettime(CLOCK_REALTIME, &cur_time); |
| exp_nsec = (long long)cur_time.tv_sec * 1000 * 1000 * 1000 + cur_time.tv_nsec; |
| if (timeout != 0) |
| exp_nsec += (timeout * 1000 - 999) * 1000; |
| timeo.tv_sec = exp_nsec / (1000 * 1000 * 1000); |
| timeo.tv_nsec = exp_nsec % (1000 * 1000 * 1000); |
| |
| (void)pthread_mutex_lock(&q->q_lock_); |
| |
| rc = list_ins_next(q, prio, msg, size, TRUE, &timeo); |
| if(HMX_OK != rc) |
| { |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| |
| if(ETIMEDOUT == rc) |
| { |
| PrintDebug("%s : list_ins_next() rc[%d] HMX_TIMEOUT!!\n", __FUNCTION__, rc); |
| return HMX_TIMEOUT; |
| } |
| else |
| { |
| PrintError("%s : list_ins_next() rc[%d] Error!!\n", __FUNCTION__, rc); |
| return HMX_ERROR; |
| } |
| } |
| |
| #ifdef DEBUG_MSG_LIST_PRINT |
| print_list(q); |
| #endif |
| |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| |
| PrintExit(); |
| |
| return HMX_OK; |
| } |
| |
| |
| /* |
| HMX_MSG_SendUrgent |
| ±ä±Þ ¸Þ¼¼Áö¸¦ º¸³½´Ù. |
| */ |
| int HMX_MSG_SendUrgent(unsigned long q_id, const void *msg, unsigned long size) |
| { |
| struct HMX_MSG_queue *q; |
| int rc = HMX_OK; |
| unsigned long prio; |
| |
| PrintEnter(); |
| |
| q = (struct HMX_MSG_queue *)q_id; |
| |
| if(size > q->msg_size_) |
| { |
| PrintError("%s[%d] : size %ld Error\n", __FUNCTION__, __LINE__, size); |
| return HMX_ERROR; |
| } |
| |
| rc = P_MSG_Check(q, q_id); |
| if (HMX_OK != rc) |
| { |
| #if defined(CONFIG_DEBUG) |
| PrintError("%s(%d) : P_MSG_Check : HMX_MSG_FULL!! queue name (%s)\n", __func__, __LINE__, q->name); |
| #endif |
| return rc; |
| } |
| |
| if(HMX_SUSPENDTYPE_PRIORITY == q->suspend_type_) |
| { |
| prio = MSG_PRIORITY_MAX-1; //°¡Àå ³ôÀº ¿ì¼±¼øÀ§·Î º¸³½´Ù. |
| } |
| else |
| { |
| prio = MSG_PRIORITY0; |
| } |
| |
| (void)pthread_mutex_lock(&q->q_lock_); |
| |
| rc = list_ins_next(q, prio, msg, size, FALSE, FALSE); |
| if(HMX_OK != rc) |
| { |
| PrintError("%s : list_ins_next() rc[%d] Error!!\n", __FUNCTION__, rc); |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| return rc; |
| } |
| |
| #ifdef DEBUG_MSG_LIST_PRINT |
| print_list(q); |
| #endif |
| |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| |
| #ifdef HMX_MSG_DEBUG |
| q->lastSendTick = VK_TIMER_GetSystemTick(); |
| #endif |
| |
| PrintExit(); |
| |
| return HMX_OK; |
| } |
| |
| |
| /* |
| HMX_MSG_SendUrgentTimeout |
| ±ä±Þ ¸Þ¼¼Áö¸¦ Timeout ³»¿¡ º¸³½´Ù. |
| */ |
| int HMX_MSG_SendUrgentTimeout(unsigned long q_id, const void *msg, unsigned long size, unsigned long timeout) |
| { |
| struct HMX_MSG_queue *q; |
| int rc = HMX_OK; |
| unsigned long prio = 0; |
| struct timespec timeo; |
| struct timespec cur_time; |
| long long exp_nsec; |
| |
| PrintEnter(); |
| |
| if (timeout == 0xFFFFFFFF) |
| { |
| return HMX_MSG_SendUrgent(q_id, msg, size); |
| } |
| |
| q = (struct HMX_MSG_queue *)q_id; |
| |
| if(size > q->msg_size_) |
| { |
| PrintError("%s[%d] : size %ld Error\n", __FUNCTION__, __LINE__, size); |
| return HMX_ERROR; |
| } |
| |
| rc = P_MSG_Check(q, q_id); |
| if (HMX_OK != rc) |
| { |
| #if defined(CONFIG_DEBUG) |
| PrintError("%s(%d) : P_MSG_Check : HMX_MSG_FULL!! queue name(%s)\n", __func__, __LINE__, q->name); |
| #endif |
| return rc; |
| } |
| |
| if(HMX_SUSPENDTYPE_PRIORITY == q->suspend_type_) |
| { |
| prio = MSG_PRIORITY_MAX-1; //°¡Àå ³ôÀº ¿ì¼±¼øÀ§·Î º¸³½´Ù. |
| } |
| else |
| { |
| prio = MSG_PRIORITY0; |
| } |
| |
| clock_gettime(CLOCK_REALTIME, &cur_time); |
| exp_nsec = (long long)cur_time.tv_sec * 1000 * 1000 * 1000 + cur_time.tv_nsec; |
| if (timeout != 0) |
| exp_nsec += (timeout * 1000 - 999) * 1000; |
| timeo.tv_sec = exp_nsec / (1000 * 1000 * 1000); |
| timeo.tv_nsec = exp_nsec % (1000 * 1000 * 1000); |
| |
| (void)pthread_mutex_lock(&q->q_lock_); |
| |
| rc = list_ins_next(q, prio, msg, size, TRUE, &timeo); |
| |
| if(HMX_OK != rc) |
| { |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| |
| if(ETIMEDOUT == rc) |
| { |
| PrintDebug("%s : list_ins_next() rc[%d] HMX_TIMEOUT!!\n", __FUNCTION__, rc); |
| return HMX_TIMEOUT; |
| } |
| else |
| { |
| PrintError("%s : list_ins_next() rc[%d] Error!!\n", __FUNCTION__, rc); |
| return HMX_ERROR; |
| } |
| } |
| |
| #ifdef DEBUG_MSG_LIST_PRINT |
| print_list(q); |
| #endif |
| |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| |
| PrintExit(); |
| |
| return HMX_OK; |
| } |
| |
| #if defined(HMX_MSG_DEBUG) && defined(VK_TASK_DEBUG) |
| #define HMX_MSG_CRITICAL_DELAY_TICK 20 |
| #define HMX_MSG_NORMAL_DELAY_TICK 200 |
| #endif |
| /* |
| HMX_MSG_Receive |
| ¸Þ¼¼Áö¸¦ ¹Þ´Â´Ù. |
| */ |
| int HMX_MSG_Receive(unsigned long q_id, void *msg, unsigned long size) |
| { |
| struct HMX_MSG_queue *q; |
| // unsigned long prio; |
| int rc = HMX_OK; |
| |
| PrintEnter(); |
| |
| HMX_TASK_CheckCallback(); |
| |
| q = (struct HMX_MSG_queue *)q_id; |
| |
| if(size > q->msg_size_) |
| { |
| PrintError("%s : size %ld Error!!\n", __FUNCTION__, size); |
| return HMX_ERROR; |
| } |
| |
| (void)pthread_mutex_lock(&q->q_lock_); |
| |
| #if defined(HMX_MSG_DEBUG) && defined(VK_TASK_DEBUG) |
| q->receiveTick = VK_TIMER_GetSystemTick(); |
| if (q->lastReceiveTick != 0 && (q->receiveTick - q->lastReceiveTick > HMX_MSG_NORMAL_DELAY_TICK)) |
| { |
| if ((q->receiveTick - tickForVkDebug) > HMX_MSG_CRITICAL_DELAY_TICK) |
| { |
| PrintError("HMX_MSG_Receive : It has excuted too long time (%d) queue(%s)\n", q->receiveTick - q->lastReceiveTick, q->name); |
| } |
| } |
| #endif |
| rc = list_rem_next(q, msg, size, FALSE, NULL); |
| #if defined(HMX_MSG_DEBUG) && defined(VK_TASK_DEBUG) |
| q->lastReceiveTick = tickForVkDebug = VK_TIMER_GetSystemTick(); |
| #endif |
| if(HMX_OK != rc) |
| { |
| PrintError("%s : list_rem_next() rc[%d] Error!!\n", __FUNCTION__, rc); |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| return rc; |
| } |
| |
| #ifdef DEBUG_MSG_LIST_PRINT |
| print_list(q); |
| #endif |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| |
| PrintExit(); |
| return HMX_OK; |
| } |
| |
| /* |
| HMX_MSG_ReceiveTimeout |
| ¸Þ¼¼Áö¸¦ Timeout³»¿¡ ¹Þ´Â´Ù. |
| */ |
| int HMX_MSG_ReceiveTimeout(unsigned long q_id, void *msg, unsigned long size, unsigned long timeout) |
| { |
| struct HMX_MSG_queue *q; |
| int rc = HMX_OK; |
| // struct timespec cur_time; |
| long long exp_nsec; |
| struct timespec timeo, cur_time; |
| |
| PrintEnter(); |
| if (timeout != 0) |
| { |
| HMX_TASK_CheckCallback(); |
| } |
| |
| if (timeout == 0xFFFFFFFF) |
| { |
| return HMX_MSG_Receive(q_id, msg, size); |
| } |
| |
| q = (struct HMX_MSG_queue *)q_id; |
| |
| if(size > q->msg_size_) |
| { |
| PrintError("%s : size %ld Error!!\n", __FUNCTION__, size); |
| return HMX_ERROR; |
| } |
| |
| clock_gettime(CLOCK_REALTIME, &cur_time); |
| exp_nsec = (long long)cur_time.tv_sec * (long long)1000 * (long long)1000 * (long long)1000 + (long long)cur_time.tv_nsec; |
| if (timeout != 0) |
| exp_nsec += (long long)(timeout * (long long)1000 - 999) * (long long)1000; |
| timeo.tv_sec = exp_nsec / (1000 * 1000 * 1000); |
| timeo.tv_nsec = exp_nsec % (1000 * 1000 * 1000); |
| |
| (void)pthread_mutex_lock(&q->q_lock_); |
| #if defined(HMX_MSG_DEBUG) && defined(VK_TASK_DEBUG) |
| q->receiveTick = VK_TIMER_GetSystemTick(); |
| if (q->lastReceiveTick != 0 && (q->receiveTick - q->lastReceiveTick > HMX_MSG_NORMAL_DELAY_TICK)) |
| { |
| if ((q->receiveTick - tickForVkDebug) > HMX_MSG_CRITICAL_DELAY_TICK) |
| { |
| PrintError("HMX_MSG_ReceiveTimeout : It has excuted too long time (%d) queue(%s)\n", q->receiveTick - q->lastReceiveTick, q->name); |
| } |
| } |
| #endif |
| |
| rc = list_rem_next(q, msg, size, TRUE, &timeo); |
| #if defined(HMX_MSG_DEBUG) && defined(VK_TASK_DEBUG) |
| q->lastReceiveTick = tickForVkDebug = VK_TIMER_GetSystemTick(); |
| #endif |
| if(HMX_OK != rc) |
| { |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| |
| if(ETIMEDOUT == rc) |
| { |
| PrintDebug("%s : list_rem_next() rc[%d] HMX_TIMEOUT!!\n", __FUNCTION__, rc); |
| return HMX_TIMEOUT; |
| } |
| else |
| { |
| PrintError("%s : list_rem_next() rc[%d] Error!!\n", __FUNCTION__, rc); |
| return HMX_ERROR; |
| } |
| } |
| |
| #ifdef DEBUG_MSG_LIST_PRINT |
| print_list(q); |
| #endif |
| |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| |
| PrintExit(); |
| return HMX_OK; |
| } |
| |
| int HMX_MSG_GetMessageCount(unsigned long q_id, unsigned long *pulMsgCount, unsigned long *pulMaxMsgCount) |
| { |
| struct HMX_MSG_queue *q; |
| |
| PrintEnter(); |
| |
| q = (struct HMX_MSG_queue *)q_id; |
| |
| (void)pthread_mutex_lock(&q->q_lock_); |
| *pulMsgCount = q->curr_msg_count_; |
| *pulMaxMsgCount = q->msg_count_; |
| (void)pthread_mutex_unlock(&q->q_lock_); |
| |
| PrintExit(); |
| return HMX_OK; |
| } |
| |
| static int P_MSG_Check(struct HMX_MSG_queue *q, unsigned long q_id) |
| { |
| unsigned long ulNearlyFullCount; |
| #if !defined(CONFIG_DEBUG) |
| UNUSED(q_id); |
| #endif |
| |
| ulNearlyFullCount = (q->msg_count_ * 3); |
| ulNearlyFullCount = ulNearlyFullCount/4; |
| |
| if(q->msg_count_ == q->curr_msg_count_) |
| { |
| #if defined(CONFIG_DEBUG) |
| if (VK_TIMER_GetSystemTick() - tickForVkDebug > 5000) |
| { |
| tickForVkDebug = VK_TIMER_GetSystemTick(); |
| // queue is full. |
| #if defined(CONFIG_DEBUG) |
| PrintError("\n!!\n!!! %s(): WARNING: queue_id 0x%X, name:%s full !!!%c\n!!!\n", __FUNCTION__, q_id, q->name, 7); |
| #if defined(VK_TASK_DEBUG) |
| VK_TASK_PrintTaskList(); |
| #endif |
| #if defined(HMX_MSG_DEBUG) |
| HMX_MSG_PrintMsgQList(); |
| #endif |
| #if defined(VK_SEM_DEBUG) |
| VK_SEM_PrintSemList(); |
| #endif |
| #else |
| PrintError("\n!!\n!!! %s(): WARNING: queue_id 0x%X, full !!!%c\n!!!\n", __FUNCTION__, q_id, 7); |
| #endif |
| } |
| #endif |
| return HMX_MSG_FULL; |
| } |
| else if( q->curr_msg_count_ > ulNearlyFullCount ) |
| { |
| #if defined(CONFIG_DEBUG) |
| PrintError("[HMX_MSG_Send] MsgQue is nearly full - SendTask:%d, QueId:0x%X, (%ld, %ld), name:%s\r\n", |
| pthread_self(), q_id, q->msg_count_, q->curr_msg_count_, q->name); |
| #endif |
| } |
| |
| return HMX_OK; |
| } |
| |
| |
| /* |
| HMX_MSG_PrintMsgQList |
| ¸Þ¼¼ÁöÅ¥ Á¤º¸¸¦ Ãâ·ÂÇÑ´Ù. |
| */ |
| #if defined(HMX_MSG_DEBUG) |
| void HMX_MSG_PrintMsgQList(void) |
| { |
| HINT32 ulCnt=0; |
| struct HMX_MSG_queue *pMsgQ; |
| |
| PrintDebug("**********************************************************\n"); |
| PrintDebug(" Name Qid Size Count Cur_Count Type\n"); |
| for (pMsgQ = msg_q_list_head.tqh_first; pMsgQ != NULL; pMsgQ = pMsgQ->entries.tqe_next) |
| { |
| PrintDebug("[%03d]%20s 0x%08X %04d %05d %09d %04d\n",ulCnt, |
| pMsgQ->name, (unsigned long)pMsgQ, pMsgQ->msg_size_, pMsgQ->msg_count_, pMsgQ->curr_msg_count_, pMsgQ->suspend_type_); |
| ulCnt++; |
| } |
| PrintDebug("**********************************************************\n"); |
| } |
| #endif |
| |
| |
| /*@}*/ |