Home | History | Annotate | Download | only in osal 
      1 /*
      2  *
      3  * Copyright 2012 Samsung Electronics S.LSI Co. LTD
      4  *
      5  * Licensed under the Apache License, Version 2.0 (the "License");
      6  * you may not use this file except in compliance with the License.
      7  * You may obtain a copy of the License at
      8  *
      9  *      http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  * Unless required by applicable law or agreed to in writing, software
     12  * distributed under the License is distributed on an "AS IS" BASIS,
     13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  * See the License for the specific language governing permissions and
     15  * limitations under the License.
     16  */
     17 
     18 /*
     19  * @file        Exynos_OSAL_Thread.c
     20  * @brief
     21  * @author      SeungBeom Kim (sbcrux.kim (at) samsung.com)
     22  * @version     2.0.0
     23  * @history
     24  *   2012.02.20 : Create
     25  */
     26 
     27 #include <stdio.h>
     28 #include <stdlib.h>
     29 #include <string.h>
     30 #include <pthread.h>
     31 #include <semaphore.h>
     32 #include <errno.h>
     33 #include <time.h>
     34 #include <unistd.h>
     35 
     36 #include "Exynos_OSAL_Memory.h"
     37 #include "Exynos_OSAL_Thread.h"
     38 
     39 #undef EXYNOS_LOG_TAG
     40 #define EXYNOS_LOG_TAG    "EXYNOS_LOG_THREAD"
     41 #define EXYNOS_LOG_OFF
     42 #include "Exynos_OSAL_Log.h"
     43 
     44 
     45 typedef struct _EXYNOS_THREAD_HANDLE_TYPE
     46 {
     47     pthread_t          pthread;
     48     pthread_attr_t     attr;
     49     struct sched_param schedparam;
     50     int                stack_size;
     51 } EXYNOS_THREAD_HANDLE_TYPE;
     52 
     53 
     54 OMX_ERRORTYPE Exynos_OSAL_ThreadCreate(OMX_HANDLETYPE *threadHandle, OMX_PTR function_name, OMX_PTR argument)
     55 {
     56     FunctionIn();
     57 
     58     int result = 0;
     59     int detach_ret = 0;
     60     EXYNOS_THREAD_HANDLE_TYPE *thread;
     61     OMX_ERRORTYPE ret = OMX_ErrorNone;
     62 
     63     thread = Exynos_OSAL_Malloc(sizeof(EXYNOS_THREAD_HANDLE_TYPE));
     64     Exynos_OSAL_Memset(thread, 0, sizeof(EXYNOS_THREAD_HANDLE_TYPE));
     65 
     66     pthread_attr_init(&thread->attr);
     67     if (thread->stack_size != 0)
     68         pthread_attr_setstacksize(&thread->attr, thread->stack_size);
     69 
     70     /* set priority */
     71     if (thread->schedparam.sched_priority != 0)
     72         pthread_attr_setschedparam(&thread->attr, &thread->schedparam);
     73 
     74     detach_ret = pthread_attr_setdetachstate(&thread->attr, PTHREAD_CREATE_JOINABLE);
     75     if (detach_ret != 0) {
     76         Exynos_OSAL_Free(thread);
     77         *threadHandle = NULL;
     78         ret = OMX_ErrorUndefined;
     79         goto EXIT;
     80     }
     81 
     82     result = pthread_create(&thread->pthread, &thread->attr, function_name, (void *)argument);
     83     /* pthread_setschedparam(thread->pthread, SCHED_RR, &thread->schedparam); */
     84 
     85     switch (result) {
     86     case 0:
     87         *threadHandle = (OMX_HANDLETYPE)thread;
     88         ret = OMX_ErrorNone;
     89         break;
     90     case EAGAIN:
     91         Exynos_OSAL_Free(thread);
     92         *threadHandle = NULL;
     93         ret = OMX_ErrorInsufficientResources;
     94         break;
     95     default:
     96         Exynos_OSAL_Free(thread);
     97         *threadHandle = NULL;
     98         ret = OMX_ErrorUndefined;
     99         break;
    100     }
    101 
    102 EXIT:
    103     FunctionOut();
    104 
    105     return ret;
    106 }
    107 
    108 OMX_ERRORTYPE Exynos_OSAL_ThreadTerminate(OMX_HANDLETYPE threadHandle)
    109 {
    110     FunctionIn();
    111 
    112     OMX_ERRORTYPE ret = OMX_ErrorNone;
    113     EXYNOS_THREAD_HANDLE_TYPE *thread = (EXYNOS_THREAD_HANDLE_TYPE *)threadHandle;
    114 
    115     if (!thread) {
    116         ret = OMX_ErrorBadParameter;
    117         goto EXIT;
    118     }
    119     if (pthread_join(thread->pthread, NULL) != 0) {
    120         ret = OMX_ErrorUndefined;
    121         goto EXIT;
    122     }
    123 
    124     Exynos_OSAL_Free(thread);
    125     ret = OMX_ErrorNone;
    126 
    127 EXIT:
    128     FunctionOut();
    129 
    130     return ret;
    131 }
    132 
    133 OMX_ERRORTYPE Exynos_OSAL_ThreadCancel(OMX_HANDLETYPE threadHandle)
    134 {
    135     EXYNOS_THREAD_HANDLE_TYPE *thread = (EXYNOS_THREAD_HANDLE_TYPE *)threadHandle;
    136 
    137     if (!thread)
    138         return OMX_ErrorBadParameter;
    139 
    140     /* thread_cancel(thread->pthread); */
    141     pthread_exit(&thread->pthread);
    142     pthread_join(thread->pthread, NULL);
    143 
    144     Exynos_OSAL_Free(thread);
    145     return OMX_ErrorNone;
    146 }
    147 
    148 void Exynos_OSAL_ThreadExit(void *value_ptr)
    149 {
    150     pthread_exit(value_ptr);
    151     return;
    152 }
    153 
    154 void Exynos_OSAL_SleepMillisec(OMX_U32 ms)
    155 {
    156     usleep(ms * 1000);
    157     return;
    158 }
    159