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