| /****************************************************************************** |
| * |
| * Copyright (C) 2018 The Android Open Source Project |
| * |
| * 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. |
| * |
| ***************************************************************************** |
| * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore |
| */ |
| |
| /*****************************************************************************/ |
| /* */ |
| /* File Name : osal_mutex.c */ |
| /* */ |
| /* Description : This file contains all the necessary function */ |
| /* definitions required to operate on mutex */ |
| /* */ |
| /* List of Functions : osal_get_mutex_handle_size */ |
| /* osal_mutex_create */ |
| /* osal_mutex_destroy */ |
| /* osal_mutex_lock */ |
| /* osal_mutex_lock_timed */ |
| /* osal_mutex_unlock */ |
| /* */ |
| /* Issues / Problems : None */ |
| /* */ |
| /* Revision History : */ |
| /* */ |
| /* DD MM YYYY Author(s) Changes (Describe the changes made) */ |
| /* 20 03 2006 Ittiam Draft */ |
| /* */ |
| /*****************************************************************************/ |
| |
| /*****************************************************************************/ |
| /* File Includes */ |
| /*****************************************************************************/ |
| |
| /* System include files */ |
| #include <stdio.h> |
| |
| #include <errno.h> |
| #include <semaphore.h> |
| #include <pthread.h> |
| #include <time.h> |
| |
| /* User include files */ |
| #include "cast_types.h" |
| #include "osal.h" |
| #include "osal_handle.h" |
| #include "osal_mutex.h" |
| |
| /*****************************************************************************/ |
| /* */ |
| /* Function Name : osal_mutex_create */ |
| /* */ |
| /* Description : This function creates the mutex and returns the handle */ |
| /* to the user. */ |
| /* */ |
| /* Inputs : OSAL handle */ |
| /* Pointer to Memory manager handle */ |
| /* */ |
| /* Globals : None */ |
| /* */ |
| /* Processing : Allocates memory for Mutex handle and calls OS specific */ |
| /* mutex create API call. */ |
| /* */ |
| /* Outputs : Mutex handle */ |
| /* */ |
| /* Returns : On SUCCESS - Mutex handle */ |
| /* On FAILURE - NULL */ |
| /* */ |
| /* Issues : None */ |
| /* */ |
| /* Revision History: */ |
| /* */ |
| /* DD MM YYYY Author(s) Changes (Describe the changes made) */ |
| /* 20 03 2006 Ittiam Draft */ |
| /* */ |
| /*****************************************************************************/ |
| |
| void *osal_mutex_create(IN void *osal_handle) |
| { |
| void *mmr_handle = 0; |
| |
| /* Currenlty naming semaphores is not supported */ |
| { |
| osal_t *handle = osal_handle; |
| mutex_handle_t *mutex_handle = 0; |
| |
| if(0 == handle || 0 == handle->alloc || 0 == handle->free) |
| return 0; |
| |
| /* Initialize MMR handle */ |
| mmr_handle = handle->mmr_handle; |
| |
| /* Allocate memory for the Handle */ |
| mutex_handle = handle->alloc(mmr_handle, sizeof(mutex_handle_t)); |
| |
| /* Error in memory allocation */ |
| if(0 == mutex_handle) |
| return 0; |
| |
| mutex_handle->mmr_handle = mmr_handle; |
| mutex_handle->hdl = handle; |
| |
| /* Create semaphore */ |
| if(0 != pthread_mutex_init(&(mutex_handle->mutex_handle), NULL)) |
| { |
| handle->free(mmr_handle, mutex_handle); |
| return 0; |
| } |
| |
| return mutex_handle; |
| } |
| } |
| |
| /*****************************************************************************/ |
| /* */ |
| /* Function Name : osal_mutex_destroy */ |
| /* */ |
| /* Description : This function destroys the mutex. */ |
| /* */ |
| /* Inputs : Mutex Handle */ |
| /* */ |
| /* Globals : None */ |
| /* */ |
| /* Processing : This function destroys the mutex refernced by the handle */ |
| /* and frees the memory held by the handle. */ |
| /* */ |
| /* Outputs : Status of mutex destroy */ |
| /* */ |
| /* Returns : On SUCCESS - 0 */ |
| /* On FAILURE - -1 */ |
| /* */ |
| /* Issues : None */ |
| /* */ |
| /* Revision History: */ |
| /* */ |
| /* DD MM YYYY Author(s) Changes (Describe the changes made) */ |
| /* 22 03 2006 Ittiam Draft */ |
| /* */ |
| /*****************************************************************************/ |
| |
| WORD32 osal_mutex_destroy(IN void *mutex_handle) |
| { |
| if(0 == mutex_handle) |
| return OSAL_ERROR; |
| |
| { |
| mutex_handle_t *handle = (mutex_handle_t *)mutex_handle; |
| WORD32 status = 0; |
| |
| if(0 == handle->hdl || 0 == handle->hdl->free) |
| return OSAL_ERROR; |
| |
| /* Destroy the mutex */ |
| status = pthread_mutex_destroy(&(handle->mutex_handle)); |
| |
| if(0 != status) |
| return OSAL_ERROR; |
| |
| /* Free the handle */ |
| handle->hdl->free(handle->mmr_handle, handle); |
| return OSAL_SUCCESS; |
| } |
| } |
| |
| /*****************************************************************************/ |
| /* */ |
| /* Function Name : osal_mutex_lock */ |
| /* */ |
| /* Description : This function locks the mutex. */ |
| /* */ |
| /* Inputs : Mutex handle */ |
| /* */ |
| /* Globals : None */ |
| /* */ |
| /* Processing : Calls OS specific mutex lock API. */ |
| /* */ |
| /* Outputs : Status of mutex lock */ |
| /* */ |
| /* Returns : On SUCCESS - 0 */ |
| /* On FAILURE - -1 */ |
| /* */ |
| /* Issues : None */ |
| /* */ |
| /* Revision History: */ |
| /* */ |
| /* DD MM YYYY Author(s) Changes (Describe the changes made) */ |
| /* 22 03 2006 Ittiam Draft */ |
| /* */ |
| /*****************************************************************************/ |
| |
| WORD32 osal_mutex_lock(IN void *mutex_handle) |
| { |
| if(0 == mutex_handle) |
| return OSAL_ERROR; |
| |
| { |
| mutex_handle_t *handle = (mutex_handle_t *)mutex_handle; |
| |
| /* Wait on mutex lock */ |
| return pthread_mutex_lock(&(handle->mutex_handle)); |
| } |
| } |
| |
| /*****************************************************************************/ |
| /* */ |
| /* Function Name : osal_mutex_unlock */ |
| /* */ |
| /* Description : This function unlocks the mutex */ |
| /* */ |
| /* Inputs : Mutex handle */ |
| /* */ |
| /* Globals : None */ |
| /* */ |
| /* Processing : Calls OS specific unlock mutex API. */ |
| /* */ |
| /* Outputs : Status of mutex unlock */ |
| /* */ |
| /* Returns : On SUCCESS - 0 */ |
| /* On FAILURE - -1 */ |
| /* */ |
| /* Issues : None */ |
| /* */ |
| /* Revision History: */ |
| /* */ |
| /* DD MM YYYY Author(s) Changes (Describe the changes made) */ |
| /* 22 03 2006 Ittiam Draft */ |
| /* */ |
| /*****************************************************************************/ |
| |
| WORD32 osal_mutex_unlock(IN void *mutex_handle) |
| { |
| if(0 == mutex_handle) |
| return OSAL_ERROR; |
| |
| { |
| mutex_handle_t *handle = (mutex_handle_t *)mutex_handle; |
| |
| /* Release the lock */ |
| if(0 == pthread_mutex_unlock(&(handle->mutex_handle))) |
| return OSAL_SUCCESS; |
| |
| return OSAL_ERROR; |
| } |
| } |
