system/wlan/ti/sta_dk_4_0_4_32/CUDK/OAL/Pform/Linux/TILibLinux.cpp

   1 /*******************************************************************************
   2 **+--------------------------------------------------------------------------+**
   3 **|                                                                          |**
   4 **| Copyright 1998-2008 Texas Instruments, Inc. - http://www.ti.com/         |**
   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
  21 // TILibLinux.cpp :
  22 //
  23 #include <stdio.h>
  24 #include <errno.h>
  25 #include <time.h>
  26
  27 #include "CommonOAL.h"
  28 #include "TILibLinux.h"
  29 #include <pthread.h>
  30
  31 //////////////////////////////////////////////////////////////////////
  32 // CTI_LibLinux Class
  33 //////////////////////////////////////////////////////////////////////
  34 TIOALib_SINGLETON_CLASS_IMP( CTI_LibLinux )
  35 TIOALib_OBJECT_CREATOR_IMP( CTI_OSCriticalSectionLinux, TI_OSWrapCriticalSection )
  36
  37 //////////////////////////////////////////////////////////////////////
  38 // Construction/Destruction
  39 //////////////////////////////////////////////////////////////////////
  40
  41 CTI_LibLinux::CTI_LibLinux()
  42 {
  43 }
  44
  45 CTI_LibLinux::~CTI_LibLinux()
  46 {
  47 }
  48
  49 tiVOID
  50 CTI_LibLinux::TIOutputDebugString (tiCHAR* lpOutputString)
  51 {
  52     if ( lpOutputString )
  53         fprintf(stderr, lpOutputString);
  54 }
  55
  56 tiUINT32
  57 CTI_LibLinux::TILoadLibrary(tiCHAR* lpLibFileName)
  58 {
  59     return 0;
  60 }
  61 tiUINT32
  62 CTI_LibLinux::TIGetCurrentThreadId()
  63 {
  64     return pthread_self();
  65 }
  66
  67 tiBOOL
  68 CTI_LibLinux::TIFreeLibrary( tiUINT32 hLibModule )
  69 {
  70     return 0;
  71 }
  72
  73 tiUINT32
  74 CTI_LibLinux::TIRegisterWindowMessage (tiCHAR* lpszMsgName)
  75 {
  76     return 0;
  77 }
  78
  79 tiBOOL
  80 CTI_LibLinux::TIPostMessage(tiUINT32 hWnd, tiUINT32 uMsg, tiUINT32 wParam, tiUINT32 lParam)
  81 {
  82     return 0;
  83 }
  84
  85 tiUINT32
  86 CTI_LibLinux::TIGetProcAddress(tiUINT32 hModule, tiCHAR* lpProcName )
  87 {
  88     return 0;
  89 }
  90
  91 tiBOOL
  92 CTI_LibLinux::TIIsBadWritePtr(tiVOID *lp, tiUINT32 ucb )
  93 {
  94     return FALSE;   //IsBadWritePtr(lp, ucb );
  95 }
  96
  97 tiVOID
  98 CTI_LibLinux::TIPrintLastError(tiCHAR* lpsz)
  99 {
 100 #ifdef DEBUG_MESSAGES
 101     tiCHAR szTmp[512];
 102     sprintf(szTmp,"%s LastError(0x%Xh)\n", lpsz, errno);
 103     TIOutputDebugString(szTmp);
 104 #endif
 105 }
 106
 107
 108 tiUINT32
 109 CTI_LibLinux::TICreateThread(tiPTHREAD_START_ROUTINE pStartAddress, tiVOID* pParameter )
 110 {
 111     uxTHREAD_START_ROUTINE  thread_start_address = (uxTHREAD_START_ROUTINE)pStartAddress;
 112     pthread_t               supp_thread_id;
 113     pthread_attr_t          supp_thread_attrs;
 114
 115     pthread_attr_init(&supp_thread_attrs);
 116
 117     int iRet = pthread_create(&supp_thread_id, &supp_thread_attrs, thread_start_address, pParameter);
 118
 119     pthread_attr_destroy(&supp_thread_attrs);
 120
 121     if ( iRet == 0)
 122         return TI_RESULT_OK;
 123
 124     return TI_RESULT_FAILED;
 125 }
 126
 127
 128 CTI_OSCriticalSectionLinux::CTI_OSCriticalSectionLinux()
 129 {
 130   /*  m_pCS = (tiVOID*) new pthread_rwlock_t;
 131
 132     if ( m_pCS )
 133     {
 134         memset( m_pCS, 0, sizeof(pthread_rwlock_t));
 135         pthread_rwlock_init((pthread_rwlock_t*) m_pCS, NULL )
 136     }
 137     */
 138 }
 139
 140 CTI_OSCriticalSectionLinux::~CTI_OSCriticalSectionLinux()
 141 {
 142     /*
 143     if (m_pCS)
 144     {
 145         pthread_rwlock_destroy((pthread_rwlock_t*) m_pCS);
 146         delete m_pCS;
 147         m_pCS = NULL;
 148     }
 149     */
 150 }
 151
 152 tiVOID
 153 CTI_OSCriticalSectionLinux::Enter()
 154 {
 155     /*
 156     if ( m_pCS )
 157         pthread_rwlock_wrlock((pthread_rwlock_t*) m_pCS);
 158     */
 159 }
 160
 161 tiVOID
 162 CTI_OSCriticalSectionLinux::Leave()
 163 {
 164     /*
 165     if ( m_pCS )
 166         pthread_rwlock_unlock((pthread_rwlock_t*) m_pCS);
 167     */
 168 }
 169
 170 tiVOID
 171 CTI_LibLinux::TISleep(tiUINT32 msec)
 172 {
 173     struct timespec req;
 174
 175     req.tv_sec = 0;
 176     req.tv_nsec = 100000; /* sleep for 100 msec */
 177     nanosleep( &req, NULL );
 178 }
 179
 180 /*
 181
 182 CTI_OSEventLinux::CTI_OSEventLinux()
 183 {
 184     m_bSet = FALSE;
 185
 186     pthread_condattr_init(&m_CondAttr);
 187     pthread_cond_init(&m_Cond, &m_CondAttr);
 188
 189     pthread_mutexattr_init(&m_MutexAttr);
 190     pthread_mutexattr_settype(&m_MutexAttr, PTHREAD_MUTEX_NORMAL);
 191
 192     m_pEvent = (tiVOID*) new pthread_mutex_t;
 193
 194     if ( m_pEvent )
 195     {
 196         memset( m_pEvent, 0, sizeof(pthread_mutex_t));
 197         pthread_mutex_init( (pthread_mutex_t*) m_pEvent, &m_MutexAttr);
 198     }
 199 }
 200
 201 CTI_OSEventLinux::~CTI_OSEventLinux()
 202 {
 203     if (m_pEvent)
 204     {
 205         pthread_mutex_destroy((pthread_mutex_t*) m_pEvent);
 206         delete m_pEvent;
 207         m_pEvent = NULL;
 208     }
 209
 210     pthread_mutexattr_destroy(&m_attr);
 211     pthread_cond_destroy(&m_Cond);
 212     pthread_condattr_destroy(&m_CondAttr);
 213 }
 214
 215 tiVOID
 216 CTI_OSEventLinux::Set()
 217 {
 218     if ( m_pEvent )
 219         pthread_cond_signal((pthread_mutex_t*) m_pEvent);
 220 }
 221
 222 tiUINT32
 223 CTI_OSEventLinux::Wait(tiUINT32 uTimeout)
 224 {
 225     if (m_pEvent)
 226     {
 227         pthread_mutex_lock((pthread_mutex_t*) m_pEvent);
 228
 229         if (uTimeout == INFINITE)
 230         {
 231             while (!m_bSet) // have to wait for the event
 232                 pthread_cond_wait(&m_Cond, (pthread_mutex_t*) m_pEvent );
 233         }
 234         else
 235         {
 236             timespec  timeOut;
 237             clock_gettime(CLOCK_REALTIME, &timeOut);
 238
 239             // if there are seconds involved
 240             if (uTimeout >= 1000)
 241             {
 242                 timeOut.tv_sec += uTimeout / 1000;
 243
 244                 // get rest
 245                 int nRemain = nMilliseconds % 1000;
 246                 if (nRemain != 0)
 247                 {
 248                     timeOut.tv_nsec +=  nRemain * 1000000L;
 249
 250                     // wrapped into the next second
 251                     if (timeOut.tv_nsec > 1000000000L)
 252                     {
 253                         timeOut.tv_nsec -= 1000000000L;
 254                         timeOut.tv_sec++;
 255                     }
 256                 }
 257             }
 258             else
 259             {
 260                 timeOut.tv_nsec +=  uTimeout * 1000000L;
 261             }
 262
 263             while (!m_bSet) // have to wait for the event
 264             {
 265                 // the following line releases the mutex and waits until the
 266                 // condition is signalled.  when the call returns, we own the
 267                 // mutex again, unless an exception is thrown, in which case
 268                 // the mutex is unlocked
 269
 270                 int nResult = pthread_cond_timedwait(&m_Cond, (pthread_mutex_t*) m_pEvent , &timeOut));
 271
 272                 if ( nResult != 0 )
 273                 {
 274                     pthread_mutex_unlock((pthread_mutex_t*) m_pEvent);
 275                     // time out, we have the lock
 276                     pthread_mutex_lock((pthread_mutex_t*) m_pEvent);
 277
 278                     // return "time out" condition
 279                     return;
 280                }
 281
 282         }
 283 };
 284
 285 inline _dcfTimeOut::_dcfTimeOut(unsigned int nMilliseconds)
 286 {
 287     int nResult = clock_gettime(CLOCK_REALTIME, &_tsWhen);
 288
 289 #ifdef _DEBUG
 290     DCF_ASSERT(nResult == 0);
 291 #endif
 292
 293
 294 }
 295     }
 296     return TI_RESULT_OK;
 297 }
 298 */
 299