Line data    Source code

       1             : /*
       2             :  *
       3             :  *    Copyright (c) 2020 Project CHIP Authors
       4             :  *    Copyright (c) 2016-2017 Nest Labs, Inc.
       5             :  *
       6             :  *    Licensed under the Apache License, Version 2.0 (the "License");
       7             :  *    you may not use this file except in compliance with the License.
       8             :  *    You may obtain a copy of the License at
       9             :  *
      10             :  *        http://www.apache.org/licenses/LICENSE-2.0
      11             :  *
      12             :  *    Unless required by applicable law or agreed to in writing, software
      13             :  *    distributed under the License is distributed on an "AS IS" BASIS,
      14             :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      15             :  *    See the License for the specific language governing permissions and
      16             :  *    limitations under the License.
      17             :  */
      18             : 
      19             : /**
      20             :  *    @file
      21             :  *      This file defines the abstraction of mutual exclusion locks
      22             :  *      offered by the target platform.
      23             :  */
      24             : 
      25             : // Include module header
      26             : #include <system/SystemMutex.h>
      27             : 
      28             : #include <lib/support/logging/CHIPLogging.h>
      29             : 
      30             : #if !CHIP_SYSTEM_CONFIG_NO_LOCKING
      31             : 
      32             : // Include system headers
      33             : #include <errno.h>
      34             : 
      35             : namespace chip {
      36             : namespace System {
      37             : 
      38             : /**
      39             :  * Initialize the mutual exclusion lock instance.
      40             :  *
      41             :  *  @param[in,out]  aThis   A zero-initialized object.
      42             :  *
      43             :  *  @retval         #CHIP_NO_ERROR                  The mutual exclusion lock is ready to use.
      44             :  *  @retval         #CHIP_ERROR_NO_MEMORY           Insufficient system memory to allocate the mutual exclusion lock.
      45             :  *  @retval         #CHIP_ERROR_INCORRECT_STATE     An unexpected system error encountered during initialization.
      46             :  */
      47             : 
      48             : #if CHIP_SYSTEM_CONFIG_POSIX_LOCKING
      49           0 : DLL_EXPORT CHIP_ERROR Mutex::Init(Mutex & aThis)
      50             : {
      51           0 :     int lSysError = pthread_mutex_init(&aThis.mPOSIXMutex, nullptr);
      52             :     CHIP_ERROR lError;
      53             : 
      54           0 :     switch (lSysError)
      55             :     {
      56           0 :     case 0:
      57           0 :         lError = CHIP_NO_ERROR;
      58           0 :         break;
      59             : 
      60           0 :     case ENOMEM:
      61           0 :         lError = CHIP_ERROR_NO_MEMORY;
      62           0 :         break;
      63             : 
      64           0 :     default:
      65           0 :         lError = CHIP_ERROR_INCORRECT_STATE;
      66           0 :         break;
      67             :     }
      68             : 
      69           0 :     return lError;
      70             : }
      71             : #endif // CHIP_SYSTEM_CONFIG_POSIX_LOCKING
      72             : 
      73             : #if CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING
      74             : DLL_EXPORT CHIP_ERROR Mutex::Init(Mutex & aThis)
      75             : {
      76             : restart:
      77             :     if (__sync_bool_compare_and_swap(&aThis.mInitialized, 0, 1))
      78             :     {
      79             : #if (configSUPPORT_STATIC_ALLOCATION == 1)
      80             :         aThis.mFreeRTOSSemaphore = xSemaphoreCreateMutexStatic(&aThis.mFreeRTOSSemaphoreObj);
      81             : #else
      82             :         aThis.mFreeRTOSSemaphore = xSemaphoreCreateMutex();
      83             : #endif
      84             :         if (aThis.mFreeRTOSSemaphore == nullptr)
      85             :         {
      86             :             aThis.mInitialized = 0;
      87             : 
      88             :             return CHIP_ERROR_NO_MEMORY;
      89             :         }
      90             :     }
      91             :     else
      92             :     {
      93             :         while (aThis.mFreeRTOSSemaphore == nullptr)
      94             :         {
      95             :             vTaskDelay(1);
      96             : 
      97             :             if (aThis.mInitialized == 0)
      98             :             {
      99             :                 goto restart;
     100             :             }
     101             :         }
     102             :     }
     103             : 
     104             :     return CHIP_NO_ERROR;
     105             : }
     106             : 
     107             : DLL_EXPORT void Mutex::Lock(void)
     108             : {
     109             :     xSemaphoreTake(this->mFreeRTOSSemaphore, portMAX_DELAY);
     110             : }
     111             : #endif // CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING
     112             : 
     113             : #if CHIP_SYSTEM_CONFIG_CMSIS_RTOS_LOCKING
     114             : DLL_EXPORT CHIP_ERROR Mutex::Init(Mutex & aThis)
     115             : {
     116             :     aThis.mCmsisRTOSMutex = osMutexNew(NULL);
     117             :     if (aThis.mCmsisRTOSMutex == NULL)
     118             :     {
     119             :         ChipLogError(chipSystemLayer, "osMutexNew failed");
     120             :         return CHIP_ERROR_NO_MEMORY;
     121             :     }
     122             :     return CHIP_NO_ERROR;
     123             : }
     124             : 
     125             : DLL_EXPORT void Mutex::Lock(void)
     126             : {
     127             :     if (mCmsisRTOSMutex && osMutexAcquire(mCmsisRTOSMutex, osWaitForever) != osOK)
     128             :     {
     129             :         ChipLogError(chipSystemLayer, "osMutexAcquire failed");
     130             :     }
     131             : }
     132             : 
     133             : DLL_EXPORT void Mutex::Unlock(void)
     134             : {
     135             :     if (mCmsisRTOSMutex && osMutexRelease(mCmsisRTOSMutex) != osOK)
     136             :     {
     137             :         ChipLogError(chipSystemLayer, "osMutexRelease failed");
     138             :     }
     139             : }
     140             : #endif // CHIP_SYSTEM_CONFIG_CMSIS_RTOS_LOCKING
     141             : 
     142             : } // namespace System
     143             : } // namespace chip
     144             : 
     145             : #endif // !CHIP_SYSTEM_CONFIG_NO_LOCKING