daemon/net_nfc_server_controller.c

   1 /*
   2  * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #define _GNU_SOURCE
  17 #include <linux/limits.h>
  18 #include <stdio.h>
  19 #include <dlfcn.h>
  20 #include <unistd.h>
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <dirent.h>
  24 #include <string.h>
  25 #include <errno.h>
  26
  27 #include <pmapi.h>/*for pm lock*/
  28
  29 #include "net_nfc_oem_controller.h"
  30 #include "net_nfc_server_controller.h"
  31 #include "net_nfc_util_internal.h"
  32 #include "net_nfc_debug_internal.h"
  33 #include "net_nfc_server_tag.h"
  34
  35 #define NET_NFC_DEFAULT_PLUGIN  "libnfc-plugin.so"
  36
  37 static net_nfc_oem_interface_s g_interface;
  38
  39 static void *net_nfc_controller_load_file(const char *dir_path, const char *filename)
  40 {
  41         struct stat st;
  42         void *handle = NULL;
  43         net_nfc_error_e result;
  44         char path[PATH_MAX] = { '\0' };
  45
  46         bool (*onload)(net_nfc_oem_interface_s *interfaces);
  47
  48         snprintf(path, PATH_MAX, "%s/%s", dir_path, filename);
  49         NFC_DBG("path : %s", path);
  50
  51         if (stat(path, &st) == -1)
  52         {
  53                 NFC_ERR("stat failed : file not found");
  54                 goto ERROR;
  55         }
  56
  57         if (S_ISREG(st.st_mode) == 0)
  58         {
  59                 NFC_ERR("S_ISREG(st.st_mode) == 0");
  60                 goto ERROR;
  61         }
  62
  63         handle = dlopen(path, RTLD_LAZY);
  64         if (NULL == handle)
  65         {
  66                 char buffer[1024];
  67                 NFC_ERR("dlopen failed, [%d] : %s",
  68                                 errno, strerror_r(errno, buffer, sizeof(buffer)));
  69                 goto ERROR;
  70         }
  71
  72         onload = dlsym(handle, "onload");
  73         if (NULL == onload)
  74         {
  75                 char buffer[1024];
  76                 NFC_ERR("dlsym failed, [%d] : %s",
  77                                 errno, strerror_r(errno, buffer, sizeof(buffer)));
  78                 goto ERROR;
  79         }
  80
  81         memset(&g_interface, 0, sizeof(g_interface));
  82         if (onload(&g_interface) == false)
  83         {
  84                 NFC_ERR("onload failed");
  85                 goto ERROR;
  86         }
  87
  88         if (net_nfc_controller_support_nfc(&result) == false)
  89         {
  90                 NFC_ERR("net_nfc_controller_support_nfc failed, [%d]", result);
  91                 goto ERROR;
  92         }
  93
  94         return handle;
  95
  96 ERROR :
  97         if (handle != NULL)
  98                 dlclose(handle);
  99
 100         return NULL;
 101 }
 102
 103 void *net_nfc_controller_onload()
 104 {
 105         DIR *dirp;
 106         struct dirent *dir;
 107
 108         void *handle = NULL;
 109
 110         dirp = opendir(NFC_MANAGER_MODULEDIR);
 111         if (NULL == dirp)
 112         {
 113                 NFC_ERR("Can not open directory %s", NFC_MANAGER_MODULEDIR);
 114                 return NULL;
 115         }
 116
 117         while ((dir = readdir(dirp)))
 118         {
 119                 if ((strcmp(dir->d_name, ".") == 0) || (strcmp(dir->d_name, "..") == 0))
 120                         continue;
 121
 122                 /* check ".so" suffix */
 123                 if (strcmp(dir->d_name + (strlen(dir->d_name) - strlen(".so")), ".so") != 0)
 124                         continue;
 125
 126                 /* check default plugin later */
 127                 if (strcmp(dir->d_name, NET_NFC_DEFAULT_PLUGIN) == 0)
 128                         continue;
 129
 130                 handle = net_nfc_controller_load_file(NFC_MANAGER_MODULEDIR, dir->d_name);
 131                 if (handle)
 132                 {
 133                         SECURE_LOGD("Successfully loaded : %s", dir->d_name);
 134                         closedir(dirp);
 135                         return handle;
 136                 }
 137         }
 138
 139         closedir(dirp);
 140
 141         /* load default plugin */
 142         handle = net_nfc_controller_load_file(NFC_MANAGER_MODULEDIR, NET_NFC_DEFAULT_PLUGIN);
 143
 144         if (handle)
 145         {
 146                 NFC_DBG("loaded default plugin : %s", NET_NFC_DEFAULT_PLUGIN);
 147                 return handle;
 148         }
 149         else
 150         {
 151                 NFC_ERR("can not load default plugin : %s", NET_NFC_DEFAULT_PLUGIN);
 152                 return NULL;
 153         }
 154 }
 155
 156 bool net_nfc_controller_unload(void *handle)
 157 {
 158         memset(&g_interface, 0x00, sizeof(net_nfc_oem_interface_s));
 159
 160         if (handle != NULL)
 161         {
 162                 dlclose(handle);
 163                 handle = NULL;
 164         }
 165         return true;
 166 }
 167
 168 bool net_nfc_controller_init(net_nfc_error_e *result)
 169 {
 170         if (g_interface.init != NULL)
 171         {
 172                 return g_interface.init(result);
 173         }
 174         else
 175         {
 176                 NFC_ERR("interface is null");
 177                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 178                 return false;
 179         }
 180 }
 181
 182 bool net_nfc_controller_deinit(void)
 183 {
 184         if (g_interface.deinit != NULL)
 185         {
 186                 return g_interface.deinit();
 187         }
 188         else
 189         {
 190                 NFC_ERR("interface is null");
 191                 return false;
 192         }
 193 }
 194
 195 bool net_nfc_controller_register_listener(
 196                 target_detection_listener_cb target_detection_listener,
 197                 se_transaction_listener_cb se_transaction_listener,
 198                 llcp_event_listener_cb llcp_event_listener, net_nfc_error_e *result)
 199 {
 200         if (g_interface.register_listener != NULL)
 201         {
 202                 return g_interface.register_listener(target_detection_listener,
 203                                 se_transaction_listener, llcp_event_listener, result);
 204         }
 205         else
 206         {
 207                 NFC_ERR("interface is null");
 208                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 209                 return false;
 210         }
 211 }
 212
 213 bool net_nfc_controller_unregister_listener()
 214 {
 215         if (g_interface.unregister_listener != NULL)
 216         {
 217                 return g_interface.unregister_listener();
 218         }
 219         else
 220         {
 221                 NFC_ERR("interface is null");
 222                 return false;
 223         }
 224 }
 225
 226 bool net_nfc_controller_get_firmware_version(data_s **data,
 227                 net_nfc_error_e *result)
 228 {
 229         if (g_interface.get_firmware_version != NULL)
 230         {
 231                 return g_interface.get_firmware_version(data, result);
 232         }
 233         else
 234         {
 235                 NFC_ERR("interface is null");
 236                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 237                 return false;
 238         }
 239 }
 240
 241 bool net_nfc_controller_check_firmware_version(net_nfc_error_e *result)
 242 {
 243         if (g_interface.check_firmware_version != NULL)
 244         {
 245                 return g_interface.check_firmware_version(result);
 246         }
 247         else
 248         {
 249                 NFC_ERR("interface is null");
 250                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 251                 return false;
 252         }
 253 }
 254
 255 bool net_nfc_controller_update_firmware(net_nfc_error_e *result)
 256 {
 257         if (g_interface.update_firmeware != NULL)
 258         {
 259                 return g_interface.update_firmeware(result);
 260         }
 261         else
 262         {
 263                 NFC_ERR("interface is null");
 264                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 265                 return false;
 266         }
 267 }
 268
 269 bool net_nfc_controller_get_stack_information(
 270                 net_nfc_stack_information_s *stack_info, net_nfc_error_e *result)
 271 {
 272         if (g_interface.get_stack_information != NULL)
 273         {
 274                 return g_interface.get_stack_information(stack_info, result);
 275         }
 276         else
 277         {
 278                 NFC_ERR("interface is null");
 279                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 280                 return false;
 281         }
 282 }
 283
 284 bool net_nfc_controller_configure_discovery(net_nfc_discovery_mode_e mode,
 285                 net_nfc_event_filter_e config, net_nfc_error_e *result)
 286 {
 287         if (g_interface.configure_discovery != NULL)
 288         {
 289                 return g_interface.configure_discovery(mode, config, result);
 290         }
 291         else
 292         {
 293                 NFC_ERR("interface is null");
 294                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 295                 return false;
 296         }
 297 }
 298
 299 bool net_nfc_controller_get_secure_element_list(
 300                 net_nfc_secure_element_info_s *list,
 301                 int *count,
 302                 net_nfc_error_e *result)
 303 {
 304         if (g_interface.get_secure_element_list != NULL)
 305         {
 306                 return g_interface.get_secure_element_list(list, count, result);
 307         }
 308         else
 309         {
 310                 NFC_ERR("interface is null");
 311                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 312                 return false;
 313         }
 314 }
 315
 316 bool net_nfc_controller_set_secure_element_mode(
 317                 net_nfc_secure_element_type_e element_type,
 318                 net_nfc_secure_element_mode_e mode,
 319                 net_nfc_error_e *result)
 320 {
 321         if (g_interface.set_secure_element_mode != NULL)
 322         {
 323                 return g_interface.set_secure_element_mode(element_type, mode, result);
 324         }
 325         else
 326         {
 327                 NFC_ERR("interface is null");
 328                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 329                 return false;
 330         }
 331 }
 332
 333 bool net_nfc_controller_secure_element_open(
 334                 net_nfc_secure_element_type_e element_type,
 335                 net_nfc_target_handle_s **handle,
 336                 net_nfc_error_e *result)
 337 {
 338         int ret_val = 0;
 339
 340         ret_val = pm_lock_state(LCD_NORMAL, GOTO_STATE_NOW, 0);
 341
 342         NFC_DBG("pm_lock_state [%d]!!", ret_val);
 343
 344         if (g_interface.secure_element_open != NULL)
 345         {
 346                 return g_interface.secure_element_open(element_type, handle, result);
 347         }
 348         else
 349         {
 350                 NFC_ERR("interface is null");
 351                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 352                 return false;
 353         }
 354 }
 355
 356 bool net_nfc_controller_secure_element_get_atr(net_nfc_target_handle_s *handle,
 357                 data_s **atr, net_nfc_error_e *result)
 358 {
 359         if (g_interface.secure_element_get_atr != NULL)
 360         {
 361                 return g_interface.secure_element_get_atr(handle, atr, result);
 362         }
 363         else
 364         {
 365                 NFC_ERR("interface is null");
 366                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 367                 return false;
 368         }
 369 }
 370
 371 bool net_nfc_controller_secure_element_send_apdu(
 372                 net_nfc_target_handle_s *handle,
 373                 data_s *command,
 374                 data_s **response,
 375                 net_nfc_error_e *result)
 376 {
 377         if (g_interface.secure_element_send_apdu != NULL)
 378         {
 379                 return g_interface.secure_element_send_apdu(handle, command, response, result);
 380         }
 381         else
 382         {
 383                 NFC_ERR("interface is null");
 384                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 385                 return false;
 386         }
 387 }
 388
 389 bool net_nfc_controller_secure_element_close(net_nfc_target_handle_s *handle,
 390                 net_nfc_error_e *result)
 391 {
 392         int ret_val = 0;
 393
 394         ret_val = pm_unlock_state(LCD_NORMAL, PM_RESET_TIMER);
 395         NFC_DBG("pm_unlock_state [%d]!!", ret_val);
 396
 397         if (g_interface.secure_element_close != NULL)
 398         {
 399                 return g_interface.secure_element_close(handle, result);
 400         }
 401         else
 402         {
 403                 NFC_ERR("interface is null");
 404                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 405                 return false;
 406         }
 407 }
 408
 409 bool net_nfc_controller_check_target_presence(net_nfc_target_handle_s *handle,
 410                 net_nfc_error_e *result)
 411 {
 412         if (g_interface.check_presence != NULL)
 413         {
 414                 return g_interface.check_presence(handle, result);
 415         }
 416         else
 417         {
 418                 NFC_ERR("interface is null");
 419                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 420                 return false;
 421         }
 422 }
 423
 424 bool net_nfc_controller_connect(net_nfc_target_handle_s *handle,
 425                 net_nfc_error_e *result)
 426 {
 427         int ret_val = 0;
 428
 429         ret_val = pm_lock_state(LCD_NORMAL, GOTO_STATE_NOW, 0);
 430
 431         NFC_DBG("net_nfc_controller_connect pm_lock_state [%d]!!", ret_val);
 432
 433         if (g_interface.connect != NULL)
 434         {
 435                 return g_interface.connect(handle, result);
 436         }
 437         else
 438         {
 439                 NFC_ERR("interface is null");
 440                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 441                 return false;
 442         }
 443 }
 444
 445 bool net_nfc_controller_disconnect(net_nfc_target_handle_s *handle,
 446                 net_nfc_error_e *result)
 447 {
 448         int ret_val = 0;
 449
 450         ret_val = pm_unlock_state(LCD_NORMAL, PM_RESET_TIMER);
 451
 452         NFC_ERR("net_nfc_controller_disconnect pm_lock_state [%d]!!", ret_val);
 453
 454         if (g_interface.disconnect != NULL)
 455         {
 456                 net_nfc_server_free_target_info();
 457
 458                 return g_interface.disconnect(handle, result);
 459         }
 460         else
 461         {
 462                 NFC_ERR("interface is null");
 463                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 464                 return false;
 465         }
 466 }
 467
 468 bool net_nfc_controller_check_ndef(net_nfc_target_handle_s *handle,
 469                 uint8_t *ndef_card_state,
 470                 int *max_data_size,
 471                 int *real_data_size,
 472                 net_nfc_error_e *result)
 473 {
 474         if (g_interface.check_ndef != NULL)
 475         {
 476                 return g_interface.check_ndef(handle, ndef_card_state, max_data_size,
 477                                 real_data_size, result);
 478         }
 479         else
 480         {
 481                 NFC_ERR("interface is null");
 482                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 483                 return false;
 484         }
 485 }
 486
 487 bool net_nfc_controller_read_ndef(net_nfc_target_handle_s *handle, data_s **data,
 488                 net_nfc_error_e *result)
 489 {
 490         if (g_interface.read_ndef != NULL)
 491         {
 492                 return g_interface.read_ndef(handle, data, result);
 493         }
 494         else
 495         {
 496                 NFC_ERR("interface is null");
 497                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 498                 return false;
 499         }
 500 }
 501
 502 bool net_nfc_controller_write_ndef(net_nfc_target_handle_s *handle, data_s *data,
 503                 net_nfc_error_e *result)
 504 {
 505         if (g_interface.write_ndef != NULL)
 506         {
 507                 return g_interface.write_ndef(handle, data, result);
 508         }
 509         else
 510         {
 511                 NFC_ERR("interface is null");
 512                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 513                 return false;
 514         }
 515 }
 516
 517 bool net_nfc_controller_make_read_only_ndef(net_nfc_target_handle_s *handle,
 518                 net_nfc_error_e *result)
 519 {
 520         if (g_interface.make_read_only_ndef != NULL)
 521         {
 522                 return g_interface.make_read_only_ndef(handle, result);
 523         }
 524         else
 525         {
 526                 NFC_ERR("interface is null");
 527                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 528                 return false;
 529         }
 530 }
 531
 532 bool net_nfc_controller_format_ndef(net_nfc_target_handle_s *handle,
 533                 data_s *secure_key, net_nfc_error_e *result)
 534 {
 535         if (g_interface.format_ndef != NULL)
 536         {
 537                 return g_interface.format_ndef(handle, secure_key, result);
 538         }
 539         else
 540         {
 541                 NFC_ERR("interface is null");
 542                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 543                 return false;
 544         }
 545 }
 546
 547 bool net_nfc_controller_transceive(net_nfc_target_handle_s *handle,
 548                 net_nfc_transceive_info_s *info, data_s **data, net_nfc_error_e *result)
 549 {
 550         if (g_interface.transceive != NULL)
 551         {
 552                 return g_interface.transceive(handle, info, data, result);
 553         }
 554         else
 555         {
 556                 NFC_ERR("interface is null");
 557                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 558                 return false;
 559         }
 560 }
 561
 562 bool net_nfc_controller_exception_handler()
 563 {
 564         if (g_interface.exception_handler != NULL)
 565         {
 566                 return g_interface.exception_handler();
 567         }
 568         else
 569         {
 570                 NFC_ERR("interface is null");
 571                 return false;
 572         }
 573 }
 574
 575 bool net_nfc_controller_is_ready(net_nfc_error_e *result)
 576 {
 577         if (g_interface.is_ready != NULL)
 578         {
 579                 return g_interface.is_ready(result);
 580         }
 581         else
 582         {
 583                 NFC_ERR("interface is null");
 584                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 585                 return false;
 586         }
 587 }
 588
 589 bool net_nfc_controller_llcp_config(net_nfc_llcp_config_info_s *config,
 590                 net_nfc_error_e *result)
 591 {
 592         if (g_interface.config_llcp != NULL)
 593         {
 594                 return g_interface.config_llcp(config, result);
 595         }
 596         else
 597         {
 598                 NFC_ERR("interface is null");
 599                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 600                 return false;
 601         }
 602 }
 603 bool net_nfc_controller_llcp_check_llcp(net_nfc_target_handle_s *handle,
 604                 net_nfc_error_e *result)
 605 {
 606         if (g_interface.check_llcp_status != NULL)
 607         {
 608                 return g_interface.check_llcp_status(handle, result);
 609         }
 610         else
 611         {
 612                 NFC_ERR("interface is null");
 613                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 614                 return false;
 615         }
 616 }
 617 bool net_nfc_controller_llcp_activate_llcp(net_nfc_target_handle_s *handle,
 618                 net_nfc_error_e *result)
 619 {
 620         if (g_interface.activate_llcp != NULL)
 621         {
 622                 return g_interface.activate_llcp(handle, result);
 623         }
 624         else
 625         {
 626                 NFC_ERR("interface is null");
 627                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 628                 return false;
 629         }
 630 }
 631
 632 static GSList *llcp_sockets;
 633
 634 static gint _compare_socket_info(gconstpointer a, gconstpointer b)
 635 {
 636         int result;
 637         socket_info_t *info = (socket_info_t *)a;
 638
 639         if (info->socket == (net_nfc_llcp_socket_t)b)
 640                 result = 0;
 641         else
 642                 result = -1;
 643
 644         return result;
 645 }
 646
 647 static socket_info_t* _get_socket_info(net_nfc_llcp_socket_t socket)
 648 {
 649         GSList *item;
 650         socket_info_t *result;
 651
 652         item = g_slist_find_custom(llcp_sockets, GUINT_TO_POINTER(socket),
 653                         _compare_socket_info);
 654         if (item != NULL)
 655                 result = (socket_info_t *)item->data;
 656         else
 657                 result = NULL;
 658
 659         return result;
 660 }
 661
 662 static socket_info_t* _add_socket_info(net_nfc_llcp_socket_t socket)
 663 {
 664         socket_info_t *result;
 665
 666         _net_nfc_util_alloc_mem(result, sizeof(socket_info_t));
 667         if (result != NULL)
 668         {
 669                 result->socket = socket;
 670
 671                 llcp_sockets = g_slist_append(llcp_sockets, result);
 672         }
 673
 674         return result;
 675 }
 676
 677 static void _remove_socket_info(net_nfc_llcp_socket_t socket)
 678 {
 679         GSList *item;
 680
 681         item = g_slist_find_custom(llcp_sockets, GUINT_TO_POINTER(socket),
 682                         _compare_socket_info);
 683         if (item != NULL)
 684         {
 685                 llcp_sockets = g_slist_remove_link(llcp_sockets, item);
 686                 free(item->data);
 687         }
 688 }
 689
 690 void net_nfc_controller_llcp_socket_error_cb(net_nfc_llcp_socket_t socket,
 691                 net_nfc_error_e result, void *data, void *user_param)
 692 {
 693         socket_info_t *info;
 694
 695         info = _get_socket_info(socket);
 696         if (info != NULL)
 697         {
 698                 if (info->err_cb != NULL)
 699                         info->err_cb(socket, result, NULL, NULL, info->err_param);
 700
 701                 _remove_socket_info(socket);
 702         }
 703 }
 704
 705 bool net_nfc_controller_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 706                 net_nfc_socket_type_e socketType,
 707                 uint16_t miu,
 708                 uint8_t rw,
 709                 net_nfc_error_e *result,
 710                 net_nfc_service_llcp_cb cb,
 711                 void *user_param)
 712 {
 713         if (g_interface.create_llcp_socket != NULL)
 714         {
 715                 bool ret;
 716                 socket_info_t *info;
 717
 718                 info = _add_socket_info(-1);
 719                 if (NULL == info)
 720                 {
 721                         NFC_ERR("_net_nfc_util_alloc_mem failed");
 722                         *result = NET_NFC_ALLOC_FAIL;
 723                         return false;
 724                 }
 725
 726                 ret = g_interface.create_llcp_socket(socket, socketType, miu, rw, result, NULL);
 727                 if (true == ret)
 728                 {
 729                         info->socket = *socket;
 730                         info->err_cb = cb;
 731                         info->err_param = user_param;
 732                 }
 733                 else
 734                 {
 735                         _remove_socket_info(-1);
 736                 }
 737
 738                 return ret;
 739         }
 740         else
 741         {
 742                 NFC_ERR("interface is null");
 743                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 744                 return false;
 745         }
 746 }
 747
 748 bool net_nfc_controller_llcp_bind(net_nfc_llcp_socket_t socket,
 749                 uint8_t service_access_point, net_nfc_error_e *result)
 750 {
 751         if (g_interface.bind_llcp_socket != NULL)
 752         {
 753                 return g_interface.bind_llcp_socket(socket, service_access_point, result);
 754         }
 755         else
 756         {
 757                 NFC_ERR("interface is null");
 758                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 759                 return false;
 760         }
 761 }
 762
 763 void net_nfc_controller_llcp_incoming_cb(net_nfc_llcp_socket_t socket,
 764                 net_nfc_error_e result, void *data, void *user_param)
 765 {
 766         socket_info_t *info = (socket_info_t *)user_param;
 767
 768         info = _get_socket_info(info->socket);
 769         if (info != NULL)
 770         {
 771                 if (_add_socket_info(socket) != NULL)
 772                 {
 773                         if (info->work_cb != NULL)
 774                                 info->work_cb(socket, result, NULL, NULL, info->work_param);
 775                 }
 776                 else
 777                 {
 778                         NFC_ERR("_net_nfc_util_alloc_mem failed");
 779                 }
 780         }
 781 }
 782
 783 bool net_nfc_controller_llcp_listen(net_nfc_target_handle_s* handle,
 784                 uint8_t *service_access_name,
 785                 net_nfc_llcp_socket_t socket,
 786                 net_nfc_error_e *result,
 787                 net_nfc_service_llcp_cb cb,
 788                 void *user_param)
 789 {
 790         if (g_interface.listen_llcp_socket != NULL)
 791         {
 792                 socket_info_t *info;
 793
 794                 info = _get_socket_info(socket);
 795                 if (NULL == info)
 796                 {
 797                         NFC_ERR("_get_socket_info failed");
 798                         *result = NET_NFC_INVALID_HANDLE;
 799                         return false;
 800                 }
 801
 802                 info->work_cb = cb;
 803                 info->work_param = user_param;
 804
 805                 return g_interface.listen_llcp_socket(handle, service_access_name, socket,
 806                                 result, info);
 807         }
 808         else
 809         {
 810                 NFC_ERR("interface is null");
 811                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 812                 return false;
 813         }
 814 }
 815
 816 bool net_nfc_controller_llcp_accept(net_nfc_llcp_socket_t socket,
 817                 net_nfc_error_e *result, net_nfc_service_llcp_cb cb, void *user_param)
 818 {
 819         if (g_interface.accept_llcp_socket != NULL)
 820         {
 821                 socket_info_t *info;
 822
 823                 info = _get_socket_info(socket);
 824                 if (NULL == info)
 825                 {
 826                         NFC_ERR("_get_socket_info failed");
 827                         *result = NET_NFC_INVALID_HANDLE;
 828                         return false;
 829                 }
 830
 831                 info->err_cb = cb;
 832                 info->err_param = user_param;
 833
 834                 return g_interface.accept_llcp_socket(socket, result, NULL);
 835         }
 836         else
 837         {
 838                 NFC_ERR("interface is null");
 839                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 840                 return false;
 841         }
 842 }
 843
 844 bool net_nfc_controller_llcp_reject(net_nfc_target_handle_s *handle,
 845                 net_nfc_llcp_socket_t socket, net_nfc_error_e *result)
 846 {
 847         if (g_interface.reject_llcp != NULL)
 848         {
 849                 bool ret;
 850
 851                 ret = g_interface.reject_llcp(handle, socket, result);
 852                 if (true == ret)
 853                         _remove_socket_info(socket);
 854
 855                 return ret;
 856         }
 857         else
 858         {
 859                 NFC_ERR("interface is null");
 860                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 861                 return false;
 862         }
 863 }
 864
 865 void net_nfc_controller_llcp_connected_cb(net_nfc_llcp_socket_t socket,
 866                 net_nfc_error_e result, void *data, void *user_param)
 867 {
 868         net_nfc_llcp_param_t *param = (net_nfc_llcp_param_t *)user_param;
 869
 870         RET_IF(NULL == param);
 871
 872         if (param->cb != NULL)
 873                 param->cb(param->socket, result, NULL, NULL, param->user_param);
 874
 875         _net_nfc_util_free_mem(param);
 876 }
 877
 878 bool net_nfc_controller_llcp_connect_by_url(net_nfc_target_handle_s *handle,
 879                 net_nfc_llcp_socket_t socket,
 880                 uint8_t *service_access_name,
 881                 net_nfc_error_e *result,
 882                 net_nfc_service_llcp_cb cb,
 883                 void *user_param)
 884 {
 885         int ret_val = 0;
 886
 887         ret_val = pm_lock_state(LCD_NORMAL, GOTO_STATE_NOW, 0);
 888
 889         NFC_DBG("pm_lock_state[%d]!!", ret_val);
 890
 891         if (g_interface.connect_llcp_by_url != NULL)
 892         {
 893                 net_nfc_llcp_param_t *param = NULL;
 894
 895                 _net_nfc_util_alloc_mem(param, sizeof(*param));
 896                 if (NULL == param)
 897                 {
 898                         NFC_ERR("_net_nfc_util_alloc_mem failed");
 899                         *result = NET_NFC_ALLOC_FAIL;
 900                         return false;
 901                 }
 902
 903                 param->socket = socket;
 904                 param->cb = cb;
 905                 param->user_param = user_param;
 906
 907                 return g_interface.connect_llcp_by_url(handle, socket, service_access_name,
 908                                 result, param);
 909         }
 910         else
 911         {
 912                 NFC_ERR("interface is null");
 913                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 914                 return false;
 915         }
 916 }
 917
 918 bool net_nfc_controller_llcp_connect(net_nfc_target_handle_s *handle,
 919                 net_nfc_llcp_socket_t socket,
 920                 uint8_t service_access_point,
 921                 net_nfc_error_e *result,
 922                 net_nfc_service_llcp_cb cb,
 923                 void *user_param)
 924 {
 925         int ret_val = 0;
 926
 927         ret_val = pm_lock_state(LCD_NORMAL, GOTO_STATE_NOW, 0);
 928
 929         NFC_DBG("net_nfc_controller_llcp_connect pm_lock_state [%d]!!", ret_val);
 930
 931         if (g_interface.connect_llcp != NULL)
 932         {
 933                 net_nfc_llcp_param_t *param = NULL;
 934
 935                 _net_nfc_util_alloc_mem(param, sizeof(*param));
 936                 if (param == NULL) {
 937                         NFC_ERR("_net_nfc_util_alloc_mem failed");
 938                         *result = NET_NFC_ALLOC_FAIL;
 939                         return false;
 940                 }
 941
 942                 param->socket = socket;
 943                 param->cb = cb;
 944                 param->user_param = user_param;
 945
 946                 return g_interface.connect_llcp(handle, socket, service_access_point, result, param);
 947         }
 948         else
 949         {
 950                 NFC_ERR("interface is null");
 951                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 952                 return false;
 953         }
 954 }
 955
 956 void net_nfc_controller_llcp_disconnected_cb(net_nfc_llcp_socket_t socket,
 957                 net_nfc_error_e result, void *data, void *user_param)
 958 {
 959         net_nfc_llcp_param_t *param = (net_nfc_llcp_param_t *)user_param;
 960
 961         RET_IF(NULL == param);
 962
 963         if (param->cb != NULL)
 964                 param->cb(param->socket, result, NULL, NULL, param->user_param);
 965
 966         _net_nfc_util_free_mem(param);
 967 }
 968
 969 bool net_nfc_controller_llcp_disconnect(net_nfc_target_handle_s *handle,
 970                 net_nfc_llcp_socket_t socket,
 971                 net_nfc_error_e *result,
 972                 net_nfc_service_llcp_cb cb,
 973                 void *user_param)
 974 {
 975         int ret_val = 0;
 976
 977         ret_val = pm_unlock_state(LCD_NORMAL, PM_RESET_TIMER);
 978
 979         NFC_DBG("net_nfc_controller_llcp_disconnect pm_unlock_state [%d]!!", ret_val);
 980
 981         if (g_interface.disconnect_llcp != NULL)
 982         {
 983                 net_nfc_llcp_param_t *param = NULL;
 984
 985                 _net_nfc_util_alloc_mem(param, sizeof(net_nfc_llcp_param_t));
 986                 if (NULL == param)
 987                 {
 988                         NFC_ERR("_net_nfc_util_alloc_mem failed");
 989                         *result = NET_NFC_ALLOC_FAIL;
 990                         return false;
 991                 }
 992
 993                 param->socket = socket;
 994                 param->cb = cb;
 995                 param->user_param = user_param;
 996
 997                 return g_interface.disconnect_llcp(handle, socket, result, param);
 998         }
 999         else
1000         {
1001                 NFC_ERR("interface is null");
1002                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1003                 return false;
1004         }
1005 }
1006
1007 bool net_nfc_controller_llcp_socket_close(net_nfc_llcp_socket_t socket,
1008                 net_nfc_error_e *result)
1009 {
1010         if (g_interface.close_llcp_socket != NULL)
1011         {
1012                 return g_interface.close_llcp_socket(socket, result);
1013         }
1014         else
1015         {
1016                 NFC_ERR("interface is null");
1017                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1018                 return false;
1019         }
1020 }
1021
1022 void net_nfc_controller_llcp_received_cb(net_nfc_llcp_socket_t socket,
1023                 net_nfc_error_e result, void *data, void *user_param)
1024 {
1025         net_nfc_llcp_param_t *param = (net_nfc_llcp_param_t *)user_param;
1026
1027         RET_IF(NULL == param);
1028
1029         if (param->cb != NULL)
1030                 param->cb(param->socket, result, &param->data, data, param->user_param);
1031
1032         if (param->data.buffer != NULL)
1033                 _net_nfc_util_free_mem(param->data.buffer);
1034
1035         _net_nfc_util_free_mem(param);
1036 }
1037
1038 bool net_nfc_controller_llcp_recv(net_nfc_target_handle_s *handle,
1039                 net_nfc_llcp_socket_t socket,
1040                 uint32_t max_len,
1041                 net_nfc_error_e *result,
1042                 net_nfc_service_llcp_cb cb,
1043                 void *user_param)
1044 {
1045         if (g_interface.recv_llcp != NULL)
1046         {
1047                 net_nfc_llcp_param_t *param = NULL;
1048
1049                 _net_nfc_util_alloc_mem(param, sizeof(*param));
1050                 if (NULL == param)
1051                 {
1052                         NFC_ERR("_net_nfc_util_alloc_mem failed");
1053                         *result = NET_NFC_ALLOC_FAIL;
1054                         return false;
1055                 }
1056
1057                 param->socket = socket;
1058                 param->cb = cb;
1059                 if (max_len > 0)
1060                 {
1061                         _net_nfc_util_alloc_mem(param->data.buffer, max_len);
1062                         if (param->data.buffer == NULL)
1063                         {
1064                                 NFC_ERR("_net_nfc_util_alloc_mem failed");
1065                                 _net_nfc_util_free_mem(param);
1066                                 *result = NET_NFC_ALLOC_FAIL;
1067                                 return false;
1068                         }
1069                         param->data.length = max_len;
1070                 }
1071                 param->user_param = user_param;
1072
1073                 return g_interface.recv_llcp(handle, socket, &param->data, result, param);
1074         }
1075         else
1076         {
1077                 NFC_ERR("interface is null");
1078                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1079                 return false;
1080         }
1081 }
1082
1083 void net_nfc_controller_llcp_sent_cb(net_nfc_llcp_socket_t socket,
1084                 net_nfc_error_e result, void *data, void *user_param)
1085 {
1086         net_nfc_llcp_param_t *param = (net_nfc_llcp_param_t *)user_param;
1087
1088         RET_IF(NULL == param);
1089
1090         if (param->cb != NULL)
1091                 param->cb(param->socket, result, NULL, NULL, param->user_param);
1092
1093         _net_nfc_util_free_mem(param);
1094 }
1095
1096 bool net_nfc_controller_llcp_send(net_nfc_target_handle_s *handle,
1097                 net_nfc_llcp_socket_t socket,
1098                 data_s *data,
1099                 net_nfc_error_e *result,
1100                 net_nfc_service_llcp_cb cb,
1101                 void *user_param)
1102 {
1103         if (g_interface.send_llcp != NULL)
1104         {
1105                 net_nfc_llcp_param_t *param = NULL;
1106
1107                 _net_nfc_util_alloc_mem(param, sizeof(*param));
1108                 if (NULL == param)
1109                 {
1110                         NFC_ERR("_net_nfc_util_alloc_mem failed");
1111                         *result = NET_NFC_ALLOC_FAIL;
1112                         return false;
1113                 }
1114
1115                 param->socket = socket;
1116                 param->cb = cb;
1117                 param->user_param = user_param;
1118
1119                 return g_interface.send_llcp(handle, socket, data, result, param);
1120         }
1121         else
1122         {
1123                 NFC_ERR("interface is null");
1124                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1125                 return false;
1126         }
1127 }
1128 bool net_nfc_controller_llcp_recv_from(net_nfc_target_handle_s *handle,
1129                 net_nfc_llcp_socket_t socket,
1130                 uint32_t max_len,
1131                 net_nfc_error_e *result,
1132                 net_nfc_service_llcp_cb cb,
1133                 void *user_param)
1134 {
1135         if (g_interface.recv_from_llcp != NULL)
1136         {
1137                 net_nfc_llcp_param_t *param = NULL;
1138
1139                 _net_nfc_util_alloc_mem(param, sizeof(*param));
1140                 if (NULL == param)
1141                 {
1142                         NFC_ERR("_net_nfc_util_alloc_mem failed");
1143                         *result = NET_NFC_ALLOC_FAIL;
1144                         return false;
1145                 }
1146
1147                 param->socket = socket;
1148                 param->cb = cb;
1149                 if (max_len > 0)
1150                 {
1151                         _net_nfc_util_alloc_mem(param->data.buffer, max_len);
1152                         if (NULL == param->data.buffer)
1153                         {
1154                                 NFC_ERR("_net_nfc_util_alloc_mem failed");
1155                                 _net_nfc_util_free_mem(param);
1156                                 *result = NET_NFC_ALLOC_FAIL;
1157                                 return false;
1158                         }
1159                         param->data.length = max_len;
1160                 }
1161                 param->user_param = user_param;
1162
1163                 return g_interface.recv_from_llcp(handle, socket, &param->data, result, param);
1164         }
1165         else
1166         {
1167                 NFC_ERR("interface is null");
1168                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1169                 return false;
1170         }
1171 }
1172 bool net_nfc_controller_llcp_send_to(net_nfc_target_handle_s *handle,
1173                 net_nfc_llcp_socket_t socket,
1174                 data_s *data,
1175                 uint8_t service_access_point,
1176                 net_nfc_error_e *result,
1177                 net_nfc_service_llcp_cb cb,
1178                 void *user_param)
1179 {
1180         if (g_interface.send_to_llcp != NULL)
1181         {
1182                 net_nfc_llcp_param_t *param = NULL;
1183
1184                 _net_nfc_util_alloc_mem(param, sizeof(*param));
1185                 if (NULL == param)
1186                 {
1187                         NFC_ERR("_net_nfc_util_alloc_mem failed");
1188                         *result = NET_NFC_ALLOC_FAIL;
1189                         return false;
1190                 }
1191
1192                 param->socket = socket;
1193                 param->cb = cb;
1194                 param->user_param = user_param;
1195
1196                 return g_interface.send_to_llcp(handle, socket, data, service_access_point,
1197                                 result, param);
1198         }
1199         else
1200         {
1201                 NFC_ERR("interface is null");
1202                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1203                 return false;
1204         }
1205 }
1206
1207 bool net_nfc_controller_llcp_get_remote_config(net_nfc_target_handle_s *handle,
1208                 net_nfc_llcp_config_info_s *config, net_nfc_error_e *result)
1209 {
1210         if (g_interface.get_remote_config != NULL)
1211         {
1212                 return g_interface.get_remote_config(handle, config, result);
1213         }
1214         else
1215         {
1216                 NFC_ERR("interface is null");
1217                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1218                 return false;
1219         }
1220 }
1221 bool net_nfc_controller_llcp_get_remote_socket_info(
1222                 net_nfc_target_handle_s *handle,
1223                 net_nfc_llcp_socket_t socket,
1224                 net_nfc_llcp_socket_option_s *option,
1225                 net_nfc_error_e *result)
1226 {
1227         if (g_interface.get_remote_socket_info != NULL)
1228         {
1229                 return g_interface.get_remote_socket_info(handle, socket, option, result);
1230         }
1231         else
1232         {
1233                 NFC_ERR("interface is null");
1234                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1235                 return false;
1236         }
1237
1238 }
1239
1240 bool net_nfc_controller_sim_test(net_nfc_error_e *result)
1241 {
1242         if (g_interface.sim_test != NULL)
1243         {
1244                 return g_interface.sim_test(result);
1245         }
1246         else
1247         {
1248                 NFC_ERR("interface is null");
1249                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1250                 return false;
1251         }
1252 }
1253
1254 bool net_nfc_controller_prbs_test(net_nfc_error_e *result, uint32_t tech,
1255                 uint32_t rate)
1256 {
1257         if (g_interface.prbs_test != NULL)
1258         {
1259                 return g_interface.prbs_test(result, tech, rate);
1260         }
1261         else
1262         {
1263                 NFC_ERR("interface is null");
1264                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1265                 return false;
1266         }
1267 }
1268
1269 bool net_nfc_controller_test_mode_on(net_nfc_error_e *result)
1270 {
1271         if (g_interface.test_mode_on != NULL)
1272         {
1273                 return g_interface.test_mode_on(result);
1274         }
1275         else
1276         {
1277                 NFC_ERR("interface is null");
1278                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1279                 return false;
1280         }
1281 }
1282
1283 bool net_nfc_controller_test_mode_off(net_nfc_error_e *result)
1284 {
1285         if (g_interface.test_mode_off != NULL)
1286         {
1287                 return g_interface.test_mode_off(result);
1288         }
1289         else
1290         {
1291                 NFC_ERR("interface is null");
1292                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1293                 return false;
1294         }
1295 }
1296
1297 bool net_nfc_controller_support_nfc(net_nfc_error_e *result)
1298 {
1299         if (g_interface.support_nfc != NULL)
1300         {
1301                 return g_interface.support_nfc(result);
1302         }
1303         else
1304         {
1305                 NFC_ERR("interface is null");
1306                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1307                 return false;
1308         }
1309 }
1310
1311 bool net_nfc_controller_eedata_register_set(net_nfc_error_e *result,
1312                 uint32_t mode, uint32_t reg_id, data_s *data)
1313 {
1314         if (g_interface.eedata_register_set != NULL)
1315         {
1316                 return g_interface.eedata_register_set(result, mode, reg_id, data);
1317         }
1318         else
1319         {
1320                 NFC_ERR("interface is null");
1321                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1322                 return false;
1323         }
1324 }