src/hal-api-nfc.c

   1 /*
   2  * HAL (Hardware Abstract Layer) NFC API
   3  *
   4  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the License);
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdint.h>
  21 #include <dlfcn.h>
  22 #include <dlog.h>
  23
  24 #include <hal/hal-common.h>
  25
  26 #include "hal-nfc-interface.h"
  27 #include "hal-nfc.h"
  28 #include "common.h"
  29
  30 #ifndef EXPORT
  31 #define EXPORT __attribute__ ((visibility("default")))
  32 #endif
  33
  34 #define ARRAY_SIZE(name)        (sizeof(name)/sizeof(name[0]))
  35
  36 static hal_backend_nfc_funcs *g_nfc_funcs = NULL;
  37
  38 EXPORT
  39 int hal_nfc_get_backend(void)
  40 {
  41         int ret;
  42
  43         if (g_nfc_funcs)
  44                 return 0;
  45
  46         ret = hal_common_get_backend(HAL_MODULE_NFC, (void **)&g_nfc_funcs);
  47         if (ret < 0) {
  48                 _E("Failed to get backend\n");
  49                 return -EINVAL;
  50         }
  51
  52         return 0;
  53 }
  54
  55 EXPORT
  56 int hal_nfc_put_backend(void)
  57 {
  58         int ret;
  59
  60         if (!g_nfc_funcs)
  61                 return -EINVAL;
  62
  63         ret = hal_common_put_backend(HAL_MODULE_NFC, (void *)g_nfc_funcs);
  64         if (ret < 0) {
  65                 _E("Failed to put backend\n");
  66                 return -EINVAL;
  67         }
  68         g_nfc_funcs = NULL;
  69
  70         return 0;
  71 }
  72
  73 EXPORT
  74 bool hal_nfc_start(int *result)
  75 {
  76         if (!g_nfc_funcs)
  77                 return -ENOTSUP;
  78         return g_nfc_funcs->start(result);
  79 }
  80
  81 EXPORT
  82 bool hal_nfc_stop(void)
  83 {
  84         if (!g_nfc_funcs)
  85                 return -ENOTSUP;
  86         return g_nfc_funcs->stop();
  87 }
  88
  89 EXPORT
  90 bool hal_nfc_register_listener(target_detection_listener_cb target_detection_listener, se_transaction_listener_cb se_transaction_listener, llcp_event_listener_cb llcp_event_listener, hce_apdu_listener_cb hce_apdu_listener, net_nfc_error_e * result)
  91 {
  92         if (!g_nfc_funcs)
  93                 return -ENOTSUP;
  94         return g_nfc_funcs->register_listener(target_detection_listener, se_transaction_listener, llcp_event_listener, hce_apdu_listener, result);
  95 }
  96
  97 EXPORT
  98 bool hal_nfc_unregister_listener(void)
  99 {
 100         if (!g_nfc_funcs)
 101                 return -ENOTSUP;
 102         return g_nfc_funcs->unregister_listener();
 103 }
 104
 105 EXPORT
 106 bool hal_nfc_get_firmware_version(data_s ** data, net_nfc_error_e * result)
 107 {
 108         if (!g_nfc_funcs)
 109                 return -ENOTSUP;
 110         return g_nfc_funcs->get_firmware_version(data, result);
 111 }
 112
 113 EXPORT
 114 bool hal_nfc_support_nfc(net_nfc_error_e * result)
 115 {
 116         if (!g_nfc_funcs)
 117                 return -ENOTSUP;
 118         return g_nfc_funcs->support_nfc(result);
 119 }
 120
 121 EXPORT
 122 bool hal_nfc_check_firmware_version(net_nfc_error_e * result)
 123 {
 124         if (!g_nfc_funcs)
 125                 return -ENOTSUP;
 126         return g_nfc_funcs->check_firmware_version(result);
 127 }
 128
 129 EXPORT
 130 bool hal_nfc_update_firmware(net_nfc_error_e * result)
 131 {
 132         if (!g_nfc_funcs)
 133                 return -ENOTSUP;
 134         return g_nfc_funcs->update_firmware(result);
 135 }
 136
 137 EXPORT
 138 bool hal_nfc_get_stack_information(net_nfc_stack_information_s * stack_info, net_nfc_error_e * result)
 139 {
 140         if (!g_nfc_funcs)
 141                 return -ENOTSUP;
 142         return g_nfc_funcs->get_stack_information(stack_info, result);
 143 }
 144
 145 EXPORT
 146 bool hal_nfc_configure_discovery(net_nfc_discovery_mode_e mode, net_nfc_event_filter_e config, net_nfc_error_e * result)
 147 {
 148         if (!g_nfc_funcs)
 149                 return -ENOTSUP;
 150         return g_nfc_funcs->configure_discovery(mode, config, result);
 151 }
 152
 153 EXPORT
 154 bool hal_nfc_check_target_presence(net_nfc_target_handle_s * handle, net_nfc_error_e * result)
 155 {
 156         if (!g_nfc_funcs)
 157                 return -ENOTSUP;
 158         return g_nfc_funcs->check_target_presence(handle, result);
 159 }
 160
 161 EXPORT
 162 bool hal_nfc_connect(net_nfc_target_handle_s * handle, net_nfc_error_e * result)
 163 {
 164         if (!g_nfc_funcs)
 165                 return -ENOTSUP;
 166         return g_nfc_funcs->connect(handle, result);
 167 }
 168
 169 EXPORT
 170 bool hal_nfc_disconnect(net_nfc_target_handle_s * handle, net_nfc_error_e * result)
 171 {
 172         if (!g_nfc_funcs)
 173                 return -ENOTSUP;
 174         return g_nfc_funcs->disconnect(handle, result);
 175 }
 176
 177 EXPORT
 178 bool hal_nfc_check_ndef(net_nfc_target_handle_s * handle, uint8_t * ndef_card_state, int *max_data_size, int *real_data_size, net_nfc_error_e * result)
 179 {
 180         if (!g_nfc_funcs)
 181                 return -ENOTSUP;
 182         return g_nfc_funcs->check_ndef(handle, ndef_card_state, max_data_size, real_data_size, result);
 183 }
 184
 185 EXPORT
 186 bool hal_nfc_read_ndef(net_nfc_target_handle_s * handle, data_s ** data, net_nfc_error_e * result)
 187 {
 188         if (!g_nfc_funcs)
 189                 return -ENOTSUP;
 190         return g_nfc_funcs->read_ndef(handle, data, result);
 191 }
 192
 193 EXPORT
 194 bool hal_nfc_write_ndef(net_nfc_target_handle_s * handle, data_s * data, net_nfc_error_e * result)
 195 {
 196         if (!g_nfc_funcs)
 197                 return -ENOTSUP;
 198         return g_nfc_funcs->write_ndef(handle, data, result);
 199 }
 200
 201 EXPORT
 202 bool hal_nfc_make_read_only_ndef(net_nfc_target_handle_s * handle, net_nfc_error_e * result)
 203 {
 204         if (!g_nfc_funcs)
 205                 return -ENOTSUP;
 206         return g_nfc_funcs->make_read_only_ndef(handle, result);
 207 }
 208
 209 EXPORT
 210 bool hal_nfc_format_ndef(net_nfc_target_handle_s * handle, data_s * secure_key, net_nfc_error_e * result)
 211 {
 212         if (!g_nfc_funcs)
 213                 return -ENOTSUP;
 214         return g_nfc_funcs->format_ndef(handle, secure_key, result);
 215 }
 216
 217 EXPORT
 218 bool hal_nfc_transceive(net_nfc_target_handle_s * handle, net_nfc_transceive_info_s * info, data_s ** data, net_nfc_error_e * result)
 219 {
 220         if (!g_nfc_funcs)
 221                 return -ENOTSUP;
 222         return g_nfc_funcs->transceive(handle, info, data, result);
 223 }
 224
 225 EXPORT
 226 bool hal_nfc_exception_handler(void)
 227 {
 228         if (!g_nfc_funcs)
 229                 return -ENOTSUP;
 230         return g_nfc_funcs->exception_handler();
 231 }
 232
 233 EXPORT
 234 bool hal_nfc_is_ready(net_nfc_error_e * result)
 235 {
 236         if (!g_nfc_funcs)
 237                 return -ENOTSUP;
 238         return g_nfc_funcs->is_ready(result);
 239 }
 240
 241 /* llcp api */
 242
 243 EXPORT
 244 bool hal_nfc_llcp_config(net_nfc_llcp_config_info_s * config, net_nfc_error_e * result)
 245 {
 246         if (!g_nfc_funcs)
 247                 return -ENOTSUP;
 248         return g_nfc_funcs->llcp_config(config, result);
 249 }
 250
 251 EXPORT
 252 bool hal_nfc_llcp_check_llcp(net_nfc_target_handle_s * handle, net_nfc_error_e * result)
 253 {
 254         if (!g_nfc_funcs)
 255                 return -ENOTSUP;
 256         return g_nfc_funcs->llcp_check_llcp(handle, result);
 257 }
 258
 259 EXPORT
 260 bool hal_nfc_llcp_activate_llcp(net_nfc_target_handle_s * handle, net_nfc_error_e * result)
 261 {
 262         if (!g_nfc_funcs)
 263                 return -ENOTSUP;
 264         return g_nfc_funcs->llcp_activate_llcp(handle, result);
 265 }
 266
 267 EXPORT
 268 bool hal_nfc_llcp_create_socket(net_nfc_llcp_socket_t * socket, net_nfc_socket_type_e socketType, uint16_t miu, uint8_t rw, net_nfc_error_e * result, void *user_param)
 269 {
 270         if (!g_nfc_funcs)
 271                 return -ENOTSUP;
 272         return g_nfc_funcs->llcp_create_socket(socket, socketType, miu, rw, result, user_param);
 273 }
 274
 275 EXPORT
 276 bool hal_nfc_llcp_bind(net_nfc_llcp_socket_t socket, uint8_t service_access_point, net_nfc_error_e * result)
 277 {
 278         if (!g_nfc_funcs)
 279                 return -ENOTSUP;
 280         return g_nfc_funcs->llcp_bind(socket, service_access_point, result);
 281 }
 282
 283 EXPORT
 284 bool hal_nfc_llcp_listen(net_nfc_target_handle_s * handle, uint8_t * service_access_name, net_nfc_llcp_socket_t socket, net_nfc_error_e * result, void *user_param)
 285 {
 286         if (!g_nfc_funcs)
 287                 return -ENOTSUP;
 288         return g_nfc_funcs->llcp_listen(handle, service_access_name, socket, result, user_param);
 289 }
 290
 291 EXPORT
 292 bool hal_nfc_llcp_accept(net_nfc_llcp_socket_t socket, net_nfc_error_e * result, void *user_param)
 293 {
 294         if (!g_nfc_funcs)
 295                 return -ENOTSUP;
 296         return g_nfc_funcs->llcp_accept(socket, result, user_param);
 297 }
 298
 299 EXPORT
 300 bool hal_nfc_llcp_connect_by_url(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, uint8_t * service_access_name, net_nfc_error_e * result, void *user_param)
 301 {
 302         if (!g_nfc_funcs)
 303                 return -ENOTSUP;
 304         return g_nfc_funcs->llcp_connect_by_url(handle, socket, service_access_name, result, user_param);
 305 }
 306
 307 EXPORT
 308 bool hal_nfc_llcp_connect(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, uint8_t service_access_point, net_nfc_error_e * result, void *user_param)
 309 {
 310         if (!g_nfc_funcs)
 311                 return -ENOTSUP;
 312         return g_nfc_funcs->llcp_connect(handle, socket, service_access_point, result, user_param);
 313 }
 314
 315 EXPORT
 316 bool hal_nfc_llcp_disconnect(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_error_e * result, void *user_param)
 317 {
 318         if (!g_nfc_funcs)
 319                 return -ENOTSUP;
 320         return g_nfc_funcs->llcp_disconnect(handle, socket, result, user_param);
 321 }
 322
 323 EXPORT
 324 bool hal_nfc_llcp_socket_close(net_nfc_llcp_socket_t socket, net_nfc_error_e * result)
 325 {
 326         if (!g_nfc_funcs)
 327                 return -ENOTSUP;
 328         return g_nfc_funcs->llcp_socket_close(socket, result);
 329 }
 330
 331 EXPORT
 332 bool hal_nfc_llcp_recv(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, net_nfc_error_e * result, void *user_param)
 333 {
 334         if (!g_nfc_funcs)
 335                 return -ENOTSUP;
 336         return g_nfc_funcs->llcp_recv(handle, socket, data, result, user_param);
 337 }
 338
 339 EXPORT
 340 bool hal_nfc_llcp_send(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, net_nfc_error_e * result, void *user_param)
 341 {
 342         if (!g_nfc_funcs)
 343                 return -ENOTSUP;
 344         return g_nfc_funcs->llcp_send(handle, socket, data, result, user_param);
 345 }
 346
 347 EXPORT
 348 bool hal_nfc_llcp_recv_from(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, net_nfc_error_e * result, void *user_param)
 349 {
 350         if (!g_nfc_funcs)
 351                 return -ENOTSUP;
 352         return g_nfc_funcs->llcp_recv_from(handle, socket, data, result, user_param);
 353 }
 354
 355 EXPORT
 356 bool hal_nfc_llcp_send_to(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, uint8_t service_access_point, net_nfc_error_e * result, void *user_param)
 357 {
 358         if (!g_nfc_funcs)
 359                 return -ENOTSUP;
 360         return g_nfc_funcs->llcp_send_to(handle, socket, data, service_access_point, result, user_param);
 361 }
 362
 363 EXPORT
 364 bool hal_nfc_llcp_reject(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_error_e * result)
 365 {
 366         if (!g_nfc_funcs)
 367                 return -ENOTSUP;
 368         return g_nfc_funcs->llcp_reject(handle, socket, result);
 369 }
 370
 371 EXPORT
 372 bool hal_nfc_llcp_get_remote_config(net_nfc_target_handle_s * handle, net_nfc_llcp_config_info_s * config, net_nfc_error_e * result)
 373 {
 374         if (!g_nfc_funcs)
 375                 return -ENOTSUP;
 376         return g_nfc_funcs->llcp_get_remote_config(handle, config, result);
 377 }
 378
 379 EXPORT
 380 bool hal_nfc_llcp_get_remote_socket_info(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_llcp_socket_option_s * option, net_nfc_error_e * result)
 381 {
 382         if (!g_nfc_funcs)
 383                 return -ENOTSUP;
 384         return g_nfc_funcs->llcp_get_remote_socket_info(handle, socket, option, result);
 385 }
 386
 387 /* secure element api */
 388
 389 EXPORT
 390 bool hal_nfc_secure_element_open(net_nfc_secure_element_type_e element_type, net_nfc_target_handle_s ** handle, net_nfc_error_e * result)
 391 {
 392         if (!g_nfc_funcs)
 393                 return -ENOTSUP;
 394         return g_nfc_funcs->secure_element_open(element_type, handle, result);
 395 }
 396
 397 EXPORT
 398 bool hal_nfc_secure_element_get_atr(net_nfc_target_handle_s * handle, data_s ** atr, net_nfc_error_e * result)
 399 {
 400         if (!g_nfc_funcs)
 401                 return -ENOTSUP;
 402         return g_nfc_funcs->secure_element_get_atr(handle, atr, result);
 403 }
 404
 405 EXPORT
 406 bool hal_nfc_secure_element_send_apdu(net_nfc_target_handle_s * handle, data_s * command, data_s ** response, net_nfc_error_e * result)
 407 {
 408         if (!g_nfc_funcs)
 409                 return -ENOTSUP;
 410         return g_nfc_funcs->secure_element_send_apdu(handle, command, response, result);
 411 }
 412
 413 EXPORT
 414 bool hal_nfc_secure_element_close(net_nfc_target_handle_s * handle, net_nfc_error_e * result)
 415 {
 416         if (!g_nfc_funcs)
 417                 return -ENOTSUP;
 418         return g_nfc_funcs->secure_element_close(handle, result);
 419 }
 420
 421 EXPORT
 422 bool hal_nfc_get_secure_element_list(net_nfc_secure_element_info_s * list, int *count, net_nfc_error_e * result)
 423 {
 424         if (!g_nfc_funcs)
 425                 return -ENOTSUP;
 426         return g_nfc_funcs->get_secure_element_list(list, count, result);
 427 }
 428
 429 EXPORT
 430 bool hal_nfc_set_secure_element_mode(net_nfc_secure_element_type_e element_type, net_nfc_secure_element_mode_e mode, net_nfc_error_e * result)
 431 {
 432         if (!g_nfc_funcs)
 433                 return -ENOTSUP;
 434         return g_nfc_funcs->set_secure_element_mode(element_type, mode, result);
 435 }
 436
 437 /* test api */
 438
 439 EXPORT
 440 bool hal_nfc_sim_test(net_nfc_error_e * result)
 441 {
 442         if (!g_nfc_funcs)
 443                 return -ENOTSUP;
 444         return g_nfc_funcs->sim_test(result);
 445 }
 446
 447 EXPORT
 448 bool hal_nfc_prbs_test(net_nfc_error_e * result, uint32_t tech, uint32_t rate)
 449 {
 450         if (!g_nfc_funcs)
 451                 return -ENOTSUP;
 452         return g_nfc_funcs->prbs_test(result, tech, rate);
 453 }
 454
 455 EXPORT
 456 bool hal_nfc_test_mode_on(net_nfc_error_e * result)
 457 {
 458         if (!g_nfc_funcs)
 459                 return -ENOTSUP;
 460         return g_nfc_funcs->test_mode_on(result);
 461 }
 462
 463 EXPORT
 464 bool hal_nfc_test_mode_off(net_nfc_error_e * result)
 465 {
 466         if (!g_nfc_funcs)
 467                 return -ENOTSUP;
 468         return g_nfc_funcs->test_mode_off(result);
 469 }
 470
 471 EXPORT
 472 bool hal_nfc_eedata_register_set(net_nfc_error_e * result, uint32_t mode, uint32_t reg_id, data_s * data)
 473 {
 474         if (!g_nfc_funcs)
 475                 return -ENOTSUP;
 476         return g_nfc_funcs->eedata_register_set(result, mode, reg_id, data);
 477 }
 478
 479 EXPORT
 480 bool hal_nfc_ese_test(net_nfc_error_e * result)
 481 {
 482         if (!g_nfc_funcs)
 483                 return -ENOTSUP;
 484         return g_nfc_funcs->ese_test(result);
 485 }
 486
 487 EXPORT
 488 bool hal_nfc_test_set_se_tech_type(net_nfc_error_e * result, net_nfc_se_type_e type, uint32_t tech)
 489 {
 490         if (!g_nfc_funcs)
 491                 return -ENOTSUP;
 492         return g_nfc_funcs->test_set_se_tech_type(result, type, tech);
 493 }
 494
 495 /* hce api */
 496
 497 EXPORT
 498 bool hal_nfc_hce_response_apdu(net_nfc_target_handle_s * handle, data_s * response, net_nfc_error_e * result)
 499 {
 500         if (!g_nfc_funcs)
 501                 return -ENOTSUP;
 502         return g_nfc_funcs->hce_response_apdu(handle, response, result);
 503 }
 504
 505 EXPORT
 506 bool hal_nfc_secure_element_route_aid(data_s * aid, net_nfc_se_type_e se_type, int power, net_nfc_error_e * result)
 507 {
 508         if (!g_nfc_funcs)
 509                 return -ENOTSUP;
 510         return g_nfc_funcs->secure_element_route_aid(aid, se_type, power, result);
 511 }
 512
 513 EXPORT
 514 bool hal_nfc_secure_element_unroute_aid(data_s * aid, net_nfc_error_e * result)
 515 {
 516         if (!g_nfc_funcs)
 517                 return -ENOTSUP;
 518         return g_nfc_funcs->secure_element_unroute_aid(aid, result);
 519 }
 520
 521 EXPORT
 522 bool hal_nfc_secure_element_commit_routing(net_nfc_error_e * result)
 523 {
 524         if (!g_nfc_funcs)
 525                 return -ENOTSUP;
 526         return g_nfc_funcs->secure_element_commit_routing(result);
 527 }
 528
 529 EXPORT
 530 bool hal_nfc_secure_element_set_default_route(net_nfc_se_type_e switch_on, net_nfc_se_type_e switch_off, net_nfc_se_type_e battery_off, net_nfc_error_e * result)
 531 {
 532         if (!g_nfc_funcs)
 533                 return -ENOTSUP;
 534         return g_nfc_funcs->secure_element_set_default_route(switch_on, switch_off, battery_off, result);
 535 }
 536
 537 EXPORT
 538 bool hal_nfc_secure_element_clear_aid_table(net_nfc_error_e * result)
 539 {
 540         if (!g_nfc_funcs)
 541                 return -ENOTSUP;
 542         return g_nfc_funcs->secure_element_clear_aid_table(result);
 543 }
 544
 545 EXPORT
 546 bool hal_nfc_secure_element_get_aid_table_size(int *AIDTableSize, net_nfc_error_e * result)
 547 {
 548         if (!g_nfc_funcs)
 549                 return -ENOTSUP;
 550         return g_nfc_funcs->secure_element_get_aid_table_size(AIDTableSize, result);
 551 }
 552
 553 EXPORT
 554 bool hal_nfc_secure_element_set_route_entry(net_nfc_se_entry_type_e type, net_nfc_se_tech_protocol_type_e value, net_nfc_se_type_e route, int power, net_nfc_error_e * result)
 555 {
 556         if (!g_nfc_funcs)
 557                 return -ENOTSUP;
 558         return g_nfc_funcs->secure_element_set_route_entry(type, value, route, power, result);
 559 }
 560
 561 EXPORT
 562 bool hal_nfc_secure_element_clear_routing_entry(net_nfc_se_entry_type_e type, net_nfc_error_e * result)
 563 {
 564         if (!g_nfc_funcs)
 565                 return -ENOTSUP;
 566         return g_nfc_funcs->secure_element_clear_routing_entry(type, result);
 567 }
 568
 569 EXPORT
 570 bool hal_nfc_secure_element_set_listen_tech_mask(net_nfc_se_tech_protocol_type_e screen_state, net_nfc_error_e * result)
 571 {
 572         if (!g_nfc_funcs)
 573                 return -ENOTSUP;
 574         return g_nfc_funcs->secure_element_set_listen_tech_mask(screen_state, result);
 575 }
 576
 577 EXPORT
 578 bool hal_nfc_set_screen_state(net_nfc_screen_state_type_e screen_state, net_nfc_error_e * result)
 579 {
 580         if (!g_nfc_funcs)
 581                 return -ENOTSUP;
 582         return g_nfc_funcs->set_screen_state(screen_state, result);
 583 }