1 /****************************************************************************** 2 * 3 * Copyright (C) 1999-2012 Broadcom Corporation 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 #include "OverrideLog.h" 19 #include "NfcAdaptation.h" 20 extern "C" 21 { 22 #include "gki.h" 23 #include "nfa_api.h" 24 #include "nfc_int.h" 25 } 26 #include "config.h" 27 #include "android_logmsg.h" 28 29 #define LOG_TAG "NfcAdaptation" 30 31 extern "C" void GKI_shutdown(); 32 extern void resetConfig(); 33 extern "C" void verify_stack_non_volatile_store (); 34 extern "C" void delete_stack_non_volatile_store (BOOLEAN forceDelete); 35 36 NfcAdaptation* NfcAdaptation::mpInstance = NULL; 37 ThreadMutex NfcAdaptation::sLock; 38 nfc_nci_device_t* NfcAdaptation::mHalDeviceContext = NULL; 39 tHAL_NFC_CBACK* NfcAdaptation::mHalCallback = NULL; 40 tHAL_NFC_DATA_CBACK* NfcAdaptation::mHalDataCallback = NULL; 41 ThreadCondVar NfcAdaptation::mHalOpenCompletedEvent; 42 ThreadCondVar NfcAdaptation::mHalCloseCompletedEvent; 43 44 UINT32 ScrProtocolTraceFlag = SCR_PROTO_TRACE_ALL; //0x017F00; 45 UINT8 appl_trace_level = 0xff; 46 char bcm_nfc_location[120]; 47 char nci_hal_module[64]; 48 49 static UINT8 nfa_dm_cfg[sizeof ( tNFA_DM_CFG ) ]; 50 extern tNFA_DM_CFG *p_nfa_dm_cfg; 51 extern UINT8 nfa_ee_max_ee_cfg; 52 extern const UINT8 nfca_version_string []; 53 extern const UINT8 nfa_version_string []; 54 static UINT8 deviceHostWhiteList [NFA_HCI_MAX_HOST_IN_NETWORK]; 55 static tNFA_HCI_CFG jni_nfa_hci_cfg; 56 extern tNFA_HCI_CFG *p_nfa_hci_cfg; 57 58 /******************************************************************************* 59 ** 60 ** Function: NfcAdaptation::NfcAdaptation() 61 ** 62 ** Description: class constructor 63 ** 64 ** Returns: none 65 ** 66 *******************************************************************************/ 67 NfcAdaptation::NfcAdaptation() 68 { 69 memset (&mHalEntryFuncs, 0, sizeof(mHalEntryFuncs)); 70 } 71 72 /******************************************************************************* 73 ** 74 ** Function: NfcAdaptation::~NfcAdaptation() 75 ** 76 ** Description: class destructor 77 ** 78 ** Returns: none 79 ** 80 *******************************************************************************/ 81 NfcAdaptation::~NfcAdaptation() 82 { 83 mpInstance = NULL; 84 } 85 86 /******************************************************************************* 87 ** 88 ** Function: NfcAdaptation::GetInstance() 89 ** 90 ** Description: access class singleton 91 ** 92 ** Returns: pointer to the singleton object 93 ** 94 *******************************************************************************/ 95 NfcAdaptation& NfcAdaptation::GetInstance() 96 { 97 AutoThreadMutex a(sLock); 98 99 if (!mpInstance) 100 mpInstance = new NfcAdaptation; 101 return *mpInstance; 102 } 103 104 /******************************************************************************* 105 ** 106 ** Function: NfcAdaptation::Initialize() 107 ** 108 ** Description: class initializer 109 ** 110 ** Returns: none 111 ** 112 *******************************************************************************/ 113 void NfcAdaptation::Initialize () 114 { 115 const char* func = "NfcAdaptation::Initialize"; 116 ALOGD("%s: enter", func); 117 ALOGE("%s: ver=%s nfa=%s", func, nfca_version_string, nfa_version_string); 118 unsigned long num; 119 120 if ( GetNumValue ( NAME_USE_RAW_NCI_TRACE, &num, sizeof ( num ) ) ) 121 { 122 if (num == 1) 123 { 124 // display protocol traces in raw format 125 ProtoDispAdapterUseRawOutput (TRUE); 126 ALOGD("%s: logging protocol in raw format", func); 127 } 128 } 129 if ( !GetStrValue ( NAME_NFA_STORAGE, bcm_nfc_location, sizeof ( bcm_nfc_location ) ) ) 130 { 131 strlcpy (bcm_nfc_location, "/data/nfc", sizeof(bcm_nfc_location)); 132 } 133 if ( GetNumValue ( NAME_PROTOCOL_TRACE_LEVEL, &num, sizeof ( num ) ) ) 134 ScrProtocolTraceFlag = num; 135 136 if ( GetStrValue ( NAME_NFA_DM_CFG, (char*)nfa_dm_cfg, sizeof ( nfa_dm_cfg ) ) ) 137 p_nfa_dm_cfg = ( tNFA_DM_CFG * ) &nfa_dm_cfg[0]; 138 139 if ( GetNumValue ( NAME_NFA_MAX_EE_SUPPORTED, &num, sizeof ( num ) ) ) 140 { 141 nfa_ee_max_ee_cfg = num; 142 ALOGD("%s: Overriding NFA_EE_MAX_EE_SUPPORTED to use %d", func, nfa_ee_max_ee_cfg); 143 } 144 145 //configure device host whitelist of HCI host ID's; see specification ETSI TS 102 622 V11.1.10 146 //(2012-10), section 6.1.3.1 147 num = GetStrValue ( NAME_DEVICE_HOST_WHITE_LIST, (char*) deviceHostWhiteList, sizeof ( deviceHostWhiteList ) ); 148 if (num) 149 { 150 memmove (&jni_nfa_hci_cfg, p_nfa_hci_cfg, sizeof(jni_nfa_hci_cfg)); 151 jni_nfa_hci_cfg.num_whitelist_host = (UINT8) num; //number of HCI host ID's in the whitelist 152 jni_nfa_hci_cfg.p_whitelist = deviceHostWhiteList; //array of HCI host ID's 153 p_nfa_hci_cfg = &jni_nfa_hci_cfg; 154 } 155 156 initializeGlobalAppLogLevel (); 157 158 verify_stack_non_volatile_store (); 159 if ( GetNumValue ( NAME_PRESERVE_STORAGE, (char*)&num, sizeof ( num ) ) && 160 (num == 1) ) 161 ALOGD ("%s: preserve stack NV store", __FUNCTION__); 162 else 163 { 164 delete_stack_non_volatile_store (FALSE); 165 } 166 167 GKI_init (); 168 GKI_enable (); 169 GKI_create_task ((TASKPTR)NFCA_TASK, BTU_TASK, (INT8*)"NFCA_TASK", 0, 0, (pthread_cond_t*)NULL, NULL); 170 { 171 AutoThreadMutex guard(mCondVar); 172 GKI_create_task ((TASKPTR)Thread, MMI_TASK, (INT8*)"NFCA_THREAD", 0, 0, (pthread_cond_t*)NULL, NULL); 173 mCondVar.wait(); 174 } 175 176 mHalDeviceContext = NULL; 177 mHalCallback = NULL; 178 memset (&mHalEntryFuncs, 0, sizeof(mHalEntryFuncs)); 179 InitializeHalDeviceContext (); 180 ALOGD ("%s: exit", func); 181 } 182 183 /******************************************************************************* 184 ** 185 ** Function: NfcAdaptation::Finalize() 186 ** 187 ** Description: class finalizer 188 ** 189 ** Returns: none 190 ** 191 *******************************************************************************/ 192 void NfcAdaptation::Finalize() 193 { 194 const char* func = "NfcAdaptation::Finalize"; 195 AutoThreadMutex a(sLock); 196 197 ALOGD ("%s: enter", func); 198 GKI_shutdown (); 199 200 resetConfig(); 201 202 nfc_nci_close(mHalDeviceContext); //close the HAL's device context 203 mHalDeviceContext = NULL; 204 mHalCallback = NULL; 205 memset (&mHalEntryFuncs, 0, sizeof(mHalEntryFuncs)); 206 207 ALOGD ("%s: exit", func); 208 delete this; 209 } 210 211 /******************************************************************************* 212 ** 213 ** Function: NfcAdaptation::signal() 214 ** 215 ** Description: signal the CondVar to release the thread that is waiting 216 ** 217 ** Returns: none 218 ** 219 *******************************************************************************/ 220 void NfcAdaptation::signal () 221 { 222 mCondVar.signal(); 223 } 224 225 /******************************************************************************* 226 ** 227 ** Function: NfcAdaptation::NFCA_TASK() 228 ** 229 ** Description: NFCA_TASK runs the GKI main task 230 ** 231 ** Returns: none 232 ** 233 *******************************************************************************/ 234 UINT32 NfcAdaptation::NFCA_TASK (UINT32 arg) 235 { 236 const char* func = "NfcAdaptation::NFCA_TASK"; 237 ALOGD ("%s: enter", func); 238 GKI_run (0); 239 ALOGD ("%s: exit", func); 240 return 0; 241 } 242 243 /******************************************************************************* 244 ** 245 ** Function: NfcAdaptation::Thread() 246 ** 247 ** Description: Creates work threads 248 ** 249 ** Returns: none 250 ** 251 *******************************************************************************/ 252 UINT32 NfcAdaptation::Thread (UINT32 arg) 253 { 254 const char* func = "NfcAdaptation::Thread"; 255 ALOGD ("%s: enter", func); 256 257 { 258 ThreadCondVar CondVar; 259 AutoThreadMutex guard(CondVar); 260 GKI_create_task ((TASKPTR)nfc_task, NFC_TASK, (INT8*)"NFC_TASK", 0, 0, (pthread_cond_t*)CondVar, (pthread_mutex_t*)CondVar); 261 CondVar.wait(); 262 } 263 264 NfcAdaptation::GetInstance().signal(); 265 266 GKI_exit_task (GKI_get_taskid ()); 267 ALOGD ("%s: exit", func); 268 return 0; 269 } 270 271 /******************************************************************************* 272 ** 273 ** Function: NfcAdaptation::GetHalEntryFuncs() 274 ** 275 ** Description: Get the set of HAL entry points. 276 ** 277 ** Returns: Functions pointers for HAL entry points. 278 ** 279 *******************************************************************************/ 280 tHAL_NFC_ENTRY* NfcAdaptation::GetHalEntryFuncs () 281 { 282 return &mHalEntryFuncs; 283 } 284 285 /******************************************************************************* 286 ** 287 ** Function: NfcAdaptation::InitializeHalDeviceContext 288 ** 289 ** Description: Ask the generic Android HAL to find the Broadcom-specific HAL. 290 ** 291 ** Returns: None. 292 ** 293 *******************************************************************************/ 294 void NfcAdaptation::InitializeHalDeviceContext () 295 { 296 const char* func = "NfcAdaptation::InitializeHalDeviceContext"; 297 ALOGD ("%s: enter", func); 298 int ret = 0; //0 means success 299 if ( !GetStrValue ( NAME_NCI_HAL_MODULE, nci_hal_module, sizeof ( nci_hal_module) ) ) 300 { 301 ALOGE("No HAL module specified in config, falling back to BCM2079x"); 302 strlcpy (nci_hal_module, "nfc_nci.bcm2079x", sizeof(nci_hal_module)); 303 } 304 const hw_module_t* hw_module = NULL; 305 306 mHalEntryFuncs.initialize = HalInitialize; 307 mHalEntryFuncs.terminate = HalTerminate; 308 mHalEntryFuncs.open = HalOpen; 309 mHalEntryFuncs.close = HalClose; 310 mHalEntryFuncs.core_initialized = HalCoreInitialized; 311 mHalEntryFuncs.write = HalWrite; 312 mHalEntryFuncs.prediscover = HalPrediscover; 313 mHalEntryFuncs.control_granted = HalControlGranted; 314 mHalEntryFuncs.power_cycle = HalPowerCycle; 315 mHalEntryFuncs.get_max_ee = HalGetMaxNfcee; 316 317 ret = hw_get_module (nci_hal_module, &hw_module); 318 if (ret == 0) 319 { 320 ret = nfc_nci_open (hw_module, &mHalDeviceContext); 321 if (ret != 0) 322 ALOGE ("%s: nfc_nci_open fail", func); 323 } 324 else 325 ALOGE ("%s: fail hw_get_module %s", func, nci_hal_module); 326 ALOGD ("%s: exit", func); 327 } 328 329 /******************************************************************************* 330 ** 331 ** Function: NfcAdaptation::HalInitialize 332 ** 333 ** Description: Not implemented because this function is only needed 334 ** within the HAL. 335 ** 336 ** Returns: None. 337 ** 338 *******************************************************************************/ 339 void NfcAdaptation::HalInitialize () 340 { 341 const char* func = "NfcAdaptation::HalInitialize"; 342 ALOGD ("%s", func); 343 } 344 345 /******************************************************************************* 346 ** 347 ** Function: NfcAdaptation::HalTerminate 348 ** 349 ** Description: Not implemented because this function is only needed 350 ** within the HAL. 351 ** 352 ** Returns: None. 353 ** 354 *******************************************************************************/ 355 void NfcAdaptation::HalTerminate () 356 { 357 const char* func = "NfcAdaptation::HalTerminate"; 358 ALOGD ("%s", func); 359 } 360 361 /******************************************************************************* 362 ** 363 ** Function: NfcAdaptation::HalOpen 364 ** 365 ** Description: Turn on controller, download firmware. 366 ** 367 ** Returns: None. 368 ** 369 *******************************************************************************/ 370 void NfcAdaptation::HalOpen (tHAL_NFC_CBACK *p_hal_cback, tHAL_NFC_DATA_CBACK* p_data_cback) 371 { 372 const char* func = "NfcAdaptation::HalOpen"; 373 ALOGD ("%s", func); 374 if (mHalDeviceContext) 375 { 376 mHalCallback = p_hal_cback; 377 mHalDataCallback = p_data_cback; 378 mHalDeviceContext->open (mHalDeviceContext, HalDeviceContextCallback, HalDeviceContextDataCallback); 379 } 380 } 381 382 /******************************************************************************* 383 ** 384 ** Function: NfcAdaptation::HalClose 385 ** 386 ** Description: Turn off controller. 387 ** 388 ** Returns: None. 389 ** 390 *******************************************************************************/ 391 void NfcAdaptation::HalClose () 392 { 393 const char* func = "NfcAdaptation::HalClose"; 394 ALOGD ("%s", func); 395 if (mHalDeviceContext) 396 { 397 mHalDeviceContext->close (mHalDeviceContext); 398 } 399 } 400 401 /******************************************************************************* 402 ** 403 ** Function: NfcAdaptation::HalDeviceContextCallback 404 ** 405 ** Description: Translate generic Android HAL's callback into Broadcom-specific 406 ** callback function. 407 ** 408 ** Returns: None. 409 ** 410 *******************************************************************************/ 411 void NfcAdaptation::HalDeviceContextCallback (nfc_event_t event, nfc_status_t event_status) 412 { 413 const char* func = "NfcAdaptation::HalDeviceContextCallback"; 414 ALOGD ("%s: event=%u", func, event); 415 if (mHalCallback) 416 mHalCallback (event, (tHAL_NFC_STATUS) event_status); 417 } 418 419 /******************************************************************************* 420 ** 421 ** Function: NfcAdaptation::HalDeviceContextDataCallback 422 ** 423 ** Description: Translate generic Android HAL's callback into Broadcom-specific 424 ** callback function. 425 ** 426 ** Returns: None. 427 ** 428 *******************************************************************************/ 429 void NfcAdaptation::HalDeviceContextDataCallback (uint16_t data_len, uint8_t* p_data) 430 { 431 const char* func = "NfcAdaptation::HalDeviceContextDataCallback"; 432 ALOGD ("%s: len=%u", func, data_len); 433 if (mHalDataCallback) 434 mHalDataCallback (data_len, p_data); 435 } 436 437 /******************************************************************************* 438 ** 439 ** Function: NfcAdaptation::HalWrite 440 ** 441 ** Description: Write NCI message to the controller. 442 ** 443 ** Returns: None. 444 ** 445 *******************************************************************************/ 446 void NfcAdaptation::HalWrite (UINT16 data_len, UINT8* p_data) 447 { 448 const char* func = "NfcAdaptation::HalWrite"; 449 ALOGD ("%s", func); 450 if (mHalDeviceContext) 451 { 452 mHalDeviceContext->write (mHalDeviceContext, data_len, p_data); 453 } 454 } 455 456 /******************************************************************************* 457 ** 458 ** Function: NfcAdaptation::HalCoreInitialized 459 ** 460 ** Description: Adjust the configurable parameters in the controller. 461 ** 462 ** Returns: None. 463 ** 464 *******************************************************************************/ 465 void NfcAdaptation::HalCoreInitialized (UINT8* p_core_init_rsp_params) 466 { 467 const char* func = "NfcAdaptation::HalCoreInitialized"; 468 ALOGD ("%s", func); 469 if (mHalDeviceContext) 470 { 471 mHalDeviceContext->core_initialized (mHalDeviceContext, p_core_init_rsp_params); 472 } 473 } 474 475 /******************************************************************************* 476 ** 477 ** Function: NfcAdaptation::HalPrediscover 478 ** 479 ** Description: Perform any vendor-specific pre-discovery actions (if needed) 480 ** If any actions were performed TRUE will be returned, and 481 ** HAL_PRE_DISCOVER_CPLT_EVT will notify when actions are 482 ** completed. 483 ** 484 ** Returns: TRUE if vendor-specific pre-discovery actions initialized 485 ** FALSE if no vendor-specific pre-discovery actions are needed. 486 ** 487 *******************************************************************************/ 488 BOOLEAN NfcAdaptation::HalPrediscover () 489 { 490 const char* func = "NfcAdaptation::HalPrediscover"; 491 ALOGD ("%s", func); 492 BOOLEAN retval = FALSE; 493 494 if (mHalDeviceContext) 495 { 496 retval = mHalDeviceContext->pre_discover (mHalDeviceContext); 497 } 498 return retval; 499 } 500 501 /******************************************************************************* 502 ** 503 ** Function: HAL_NfcControlGranted 504 ** 505 ** Description: Grant control to HAL control for sending NCI commands. 506 ** Call in response to HAL_REQUEST_CONTROL_EVT. 507 ** Must only be called when there are no NCI commands pending. 508 ** HAL_RELEASE_CONTROL_EVT will notify when HAL no longer 509 ** needs control of NCI. 510 ** 511 ** Returns: void 512 ** 513 *******************************************************************************/ 514 void NfcAdaptation::HalControlGranted () 515 { 516 const char* func = "NfcAdaptation::HalControlGranted"; 517 ALOGD ("%s", func); 518 if (mHalDeviceContext) 519 { 520 mHalDeviceContext->control_granted (mHalDeviceContext); 521 } 522 } 523 524 /******************************************************************************* 525 ** 526 ** Function: NfcAdaptation::HalPowerCycle 527 ** 528 ** Description: Turn off and turn on the controller. 529 ** 530 ** Returns: None. 531 ** 532 *******************************************************************************/ 533 void NfcAdaptation::HalPowerCycle () 534 { 535 const char* func = "NfcAdaptation::HalPowerCycle"; 536 ALOGD ("%s", func); 537 if (mHalDeviceContext) 538 { 539 mHalDeviceContext->power_cycle (mHalDeviceContext); 540 } 541 } 542 543 /******************************************************************************* 544 ** 545 ** Function: NfcAdaptation::HalGetMaxNfcee 546 ** 547 ** Description: Turn off and turn on the controller. 548 ** 549 ** Returns: None. 550 ** 551 *******************************************************************************/ 552 UINT8 NfcAdaptation::HalGetMaxNfcee() 553 { 554 const char* func = "NfcAdaptation::HalPowerCycle"; 555 UINT8 maxNfcee = 0; 556 ALOGD ("%s", func); 557 if (mHalDeviceContext) 558 { 559 // TODO maco call into HAL when we figure out binary compatibility. 560 return nfa_ee_max_ee_cfg; 561 562 //mHalDeviceContext->get_max_ee (mHalDeviceContext, &maxNfcee); 563 } 564 565 return maxNfcee; 566 } 567 568 569 /******************************************************************************* 570 ** 571 ** Function: NfcAdaptation::DownloadFirmware 572 ** 573 ** Description: Download firmware patch files. 574 ** 575 ** Returns: None. 576 ** 577 *******************************************************************************/ 578 void NfcAdaptation::DownloadFirmware () 579 { 580 const char* func = "NfcAdaptation::DownloadFirmware"; 581 ALOGD ("%s: enter", func); 582 HalInitialize (); 583 584 mHalOpenCompletedEvent.lock (); 585 ALOGD ("%s: try open HAL", func); 586 HalOpen (HalDownloadFirmwareCallback, HalDownloadFirmwareDataCallback); 587 mHalOpenCompletedEvent.wait (); 588 589 mHalCloseCompletedEvent.lock (); 590 ALOGD ("%s: try close HAL", func); 591 HalClose (); 592 mHalCloseCompletedEvent.wait (); 593 594 HalTerminate (); 595 ALOGD ("%s: exit", func); 596 } 597 598 /******************************************************************************* 599 ** 600 ** Function: NfcAdaptation::HalDownloadFirmwareCallback 601 ** 602 ** Description: Receive events from the HAL. 603 ** 604 ** Returns: None. 605 ** 606 *******************************************************************************/ 607 void NfcAdaptation::HalDownloadFirmwareCallback (nfc_event_t event, nfc_status_t event_status) 608 { 609 const char* func = "NfcAdaptation::HalDownloadFirmwareCallback"; 610 ALOGD ("%s: event=0x%X", func, event); 611 switch (event) 612 { 613 case HAL_NFC_OPEN_CPLT_EVT: 614 { 615 ALOGD ("%s: HAL_NFC_OPEN_CPLT_EVT", func); 616 mHalOpenCompletedEvent.signal (); 617 break; 618 } 619 case HAL_NFC_CLOSE_CPLT_EVT: 620 { 621 ALOGD ("%s: HAL_NFC_CLOSE_CPLT_EVT", func); 622 mHalCloseCompletedEvent.signal (); 623 break; 624 } 625 } 626 } 627 628 /******************************************************************************* 629 ** 630 ** Function: NfcAdaptation::HalDownloadFirmwareDataCallback 631 ** 632 ** Description: Receive data events from the HAL. 633 ** 634 ** Returns: None. 635 ** 636 *******************************************************************************/ 637 void NfcAdaptation::HalDownloadFirmwareDataCallback (uint16_t data_len, uint8_t* p_data) 638 { 639 } 640 641 642 /******************************************************************************* 643 ** 644 ** Function: ThreadMutex::ThreadMutex() 645 ** 646 ** Description: class constructor 647 ** 648 ** Returns: none 649 ** 650 *******************************************************************************/ 651 ThreadMutex::ThreadMutex() 652 { 653 pthread_mutexattr_t mutexAttr; 654 655 pthread_mutexattr_init(&mutexAttr); 656 pthread_mutex_init(&mMutex, &mutexAttr); 657 pthread_mutexattr_destroy(&mutexAttr); 658 } 659 660 /******************************************************************************* 661 ** 662 ** Function: ThreadMutex::~ThreadMutex() 663 ** 664 ** Description: class destructor 665 ** 666 ** Returns: none 667 ** 668 *******************************************************************************/ 669 ThreadMutex::~ThreadMutex() 670 { 671 pthread_mutex_destroy(&mMutex); 672 } 673 674 /******************************************************************************* 675 ** 676 ** Function: ThreadMutex::lock() 677 ** 678 ** Description: lock kthe mutex 679 ** 680 ** Returns: none 681 ** 682 *******************************************************************************/ 683 void ThreadMutex::lock() 684 { 685 pthread_mutex_lock(&mMutex); 686 } 687 688 /******************************************************************************* 689 ** 690 ** Function: ThreadMutex::unblock() 691 ** 692 ** Description: unlock the mutex 693 ** 694 ** Returns: none 695 ** 696 *******************************************************************************/ 697 void ThreadMutex::unlock() 698 { 699 pthread_mutex_unlock(&mMutex); 700 } 701 702 /******************************************************************************* 703 ** 704 ** Function: ThreadCondVar::ThreadCondVar() 705 ** 706 ** Description: class constructor 707 ** 708 ** Returns: none 709 ** 710 *******************************************************************************/ 711 ThreadCondVar::ThreadCondVar() 712 { 713 pthread_condattr_t CondAttr; 714 715 pthread_condattr_init(&CondAttr); 716 pthread_cond_init(&mCondVar, &CondAttr); 717 718 pthread_condattr_destroy(&CondAttr); 719 } 720 721 /******************************************************************************* 722 ** 723 ** Function: ThreadCondVar::~ThreadCondVar() 724 ** 725 ** Description: class destructor 726 ** 727 ** Returns: none 728 ** 729 *******************************************************************************/ 730 ThreadCondVar::~ThreadCondVar() 731 { 732 pthread_cond_destroy(&mCondVar); 733 } 734 735 /******************************************************************************* 736 ** 737 ** Function: ThreadCondVar::wait() 738 ** 739 ** Description: wait on the mCondVar 740 ** 741 ** Returns: none 742 ** 743 *******************************************************************************/ 744 void ThreadCondVar::wait() 745 { 746 pthread_cond_wait(&mCondVar, *this); 747 pthread_mutex_unlock(*this); 748 } 749 750 /******************************************************************************* 751 ** 752 ** Function: ThreadCondVar::signal() 753 ** 754 ** Description: signal the mCondVar 755 ** 756 ** Returns: none 757 ** 758 *******************************************************************************/ 759 void ThreadCondVar::signal() 760 { 761 AutoThreadMutex a(*this); 762 pthread_cond_signal(&mCondVar); 763 } 764 765 /******************************************************************************* 766 ** 767 ** Function: AutoThreadMutex::AutoThreadMutex() 768 ** 769 ** Description: class constructor, automatically lock the mutex 770 ** 771 ** Returns: none 772 ** 773 *******************************************************************************/ 774 AutoThreadMutex::AutoThreadMutex(ThreadMutex &m) 775 : mm(m) 776 { 777 mm.lock(); 778 } 779 780 /******************************************************************************* 781 ** 782 ** Function: AutoThreadMutex::~AutoThreadMutex() 783 ** 784 ** Description: class destructor, automatically unlock the mutex 785 ** 786 ** Returns: none 787 ** 788 *******************************************************************************/ 789 AutoThreadMutex::~AutoThreadMutex() 790 { 791 mm.unlock(); 792 } 793
