1 /* 2 * The NFC Controller Interface is the communication protocol between an 3 * NFC Controller (NFCC) and a Device Host (DH). 4 * 5 * Copyright (C) 2014 Marvell International Ltd. 6 * Copyright (C) 2011 Texas Instruments, Inc. 7 * 8 * Written by Ilan Elias <ilane@ti.com> 9 * 10 * Acknowledgements: 11 * This file is based on hci_event.c, which was written 12 * by Maxim Krasnyansky. 13 * 14 * This program is free software; you can redistribute it and/or modify 15 * it under the terms of the GNU General Public License version 2 16 * as published by the Free Software Foundation 17 * 18 * This program is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 * GNU General Public License for more details. 22 * 23 * You should have received a copy of the GNU General Public License 24 * along with this program; if not, see <http://www.gnu.org/licenses/>. 25 * 26 */ 27 28 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__ 29 30 #include <linux/types.h> 31 #include <linux/interrupt.h> 32 #include <linux/bitops.h> 33 #include <linux/skbuff.h> 34 35 #include "../nfc.h" 36 #include <net/nfc/nci.h> 37 #include <net/nfc/nci_core.h> 38 #include <linux/nfc.h> 39 40 /* Handle NCI Notification packets */ 41 42 static void nci_core_conn_credits_ntf_packet(struct nci_dev *ndev, 43 struct sk_buff *skb) 44 { 45 struct nci_core_conn_credit_ntf *ntf = (void *) skb->data; 46 struct nci_conn_info *conn_info; 47 int i; 48 49 pr_debug("num_entries %d\n", ntf->num_entries); 50 51 if (ntf->num_entries > NCI_MAX_NUM_CONN) 52 ntf->num_entries = NCI_MAX_NUM_CONN; 53 54 /* update the credits */ 55 for (i = 0; i < ntf->num_entries; i++) { 56 ntf->conn_entries[i].conn_id = 57 nci_conn_id(&ntf->conn_entries[i].conn_id); 58 59 pr_debug("entry[%d]: conn_id %d, credits %d\n", 60 i, ntf->conn_entries[i].conn_id, 61 ntf->conn_entries[i].credits); 62 63 conn_info = nci_get_conn_info_by_conn_id(ndev, 64 ntf->conn_entries[i].conn_id); 65 if (!conn_info) 66 return; 67 68 atomic_add(ntf->conn_entries[i].credits, 69 &conn_info->credits_cnt); 70 } 71 72 /* trigger the next tx */ 73 if (!skb_queue_empty(&ndev->tx_q)) 74 queue_work(ndev->tx_wq, &ndev->tx_work); 75 } 76 77 static void nci_core_generic_error_ntf_packet(struct nci_dev *ndev, 78 struct sk_buff *skb) 79 { 80 __u8 status = skb->data[0]; 81 82 pr_debug("status 0x%x\n", status); 83 84 if (atomic_read(&ndev->state) == NCI_W4_HOST_SELECT) { 85 /* Activation failed, so complete the request 86 (the state remains the same) */ 87 nci_req_complete(ndev, status); 88 } 89 } 90 91 static void nci_core_conn_intf_error_ntf_packet(struct nci_dev *ndev, 92 struct sk_buff *skb) 93 { 94 struct nci_core_intf_error_ntf *ntf = (void *) skb->data; 95 96 ntf->conn_id = nci_conn_id(&ntf->conn_id); 97 98 pr_debug("status 0x%x, conn_id %d\n", ntf->status, ntf->conn_id); 99 100 /* complete the data exchange transaction, if exists */ 101 if (test_bit(NCI_DATA_EXCHANGE, &ndev->flags)) 102 nci_data_exchange_complete(ndev, NULL, ntf->conn_id, -EIO); 103 } 104 105 static __u8 *nci_extract_rf_params_nfca_passive_poll(struct nci_dev *ndev, 106 struct rf_tech_specific_params_nfca_poll *nfca_poll, 107 __u8 *data) 108 { 109 nfca_poll->sens_res = __le16_to_cpu(*((__le16 *)data)); 110 data += 2; 111 112 nfca_poll->nfcid1_len = min_t(__u8, *data++, NFC_NFCID1_MAXSIZE); 113 114 pr_debug("sens_res 0x%x, nfcid1_len %d\n", 115 nfca_poll->sens_res, nfca_poll->nfcid1_len); 116 117 memcpy(nfca_poll->nfcid1, data, nfca_poll->nfcid1_len); 118 data += nfca_poll->nfcid1_len; 119 120 nfca_poll->sel_res_len = *data++; 121 122 if (nfca_poll->sel_res_len != 0) 123 nfca_poll->sel_res = *data++; 124 125 pr_debug("sel_res_len %d, sel_res 0x%x\n", 126 nfca_poll->sel_res_len, 127 nfca_poll->sel_res); 128 129 return data; 130 } 131 132 static __u8 *nci_extract_rf_params_nfcb_passive_poll(struct nci_dev *ndev, 133 struct rf_tech_specific_params_nfcb_poll *nfcb_poll, 134 __u8 *data) 135 { 136 nfcb_poll->sensb_res_len = min_t(__u8, *data++, NFC_SENSB_RES_MAXSIZE); 137 138 pr_debug("sensb_res_len %d\n", nfcb_poll->sensb_res_len); 139 140 memcpy(nfcb_poll->sensb_res, data, nfcb_poll->sensb_res_len); 141 data += nfcb_poll->sensb_res_len; 142 143 return data; 144 } 145 146 static __u8 *nci_extract_rf_params_nfcf_passive_poll(struct nci_dev *ndev, 147 struct rf_tech_specific_params_nfcf_poll *nfcf_poll, 148 __u8 *data) 149 { 150 nfcf_poll->bit_rate = *data++; 151 nfcf_poll->sensf_res_len = min_t(__u8, *data++, NFC_SENSF_RES_MAXSIZE); 152 153 pr_debug("bit_rate %d, sensf_res_len %d\n", 154 nfcf_poll->bit_rate, nfcf_poll->sensf_res_len); 155 156 memcpy(nfcf_poll->sensf_res, data, nfcf_poll->sensf_res_len); 157 data += nfcf_poll->sensf_res_len; 158 159 return data; 160 } 161 162 static __u8 *nci_extract_rf_params_nfcv_passive_poll(struct nci_dev *ndev, 163 struct rf_tech_specific_params_nfcv_poll *nfcv_poll, 164 __u8 *data) 165 { 166 ++data; 167 nfcv_poll->dsfid = *data++; 168 memcpy(nfcv_poll->uid, data, NFC_ISO15693_UID_MAXSIZE); 169 data += NFC_ISO15693_UID_MAXSIZE; 170 return data; 171 } 172 173 static __u8 *nci_extract_rf_params_nfcf_passive_listen(struct nci_dev *ndev, 174 struct rf_tech_specific_params_nfcf_listen *nfcf_listen, 175 __u8 *data) 176 { 177 nfcf_listen->local_nfcid2_len = min_t(__u8, *data++, 178 NFC_NFCID2_MAXSIZE); 179 memcpy(nfcf_listen->local_nfcid2, data, nfcf_listen->local_nfcid2_len); 180 data += nfcf_listen->local_nfcid2_len; 181 182 return data; 183 } 184 185 static __u32 nci_get_prop_rf_protocol(struct nci_dev *ndev, __u8 rf_protocol) 186 { 187 if (ndev->ops->get_rfprotocol) 188 return ndev->ops->get_rfprotocol(ndev, rf_protocol); 189 return 0; 190 } 191 192 static int nci_add_new_protocol(struct nci_dev *ndev, 193 struct nfc_target *target, 194 __u8 rf_protocol, 195 __u8 rf_tech_and_mode, 196 void *params) 197 { 198 struct rf_tech_specific_params_nfca_poll *nfca_poll; 199 struct rf_tech_specific_params_nfcb_poll *nfcb_poll; 200 struct rf_tech_specific_params_nfcf_poll *nfcf_poll; 201 struct rf_tech_specific_params_nfcv_poll *nfcv_poll; 202 __u32 protocol; 203 204 if (rf_protocol == NCI_RF_PROTOCOL_T1T) 205 protocol = NFC_PROTO_JEWEL_MASK; 206 else if (rf_protocol == NCI_RF_PROTOCOL_T2T) 207 protocol = NFC_PROTO_MIFARE_MASK; 208 else if (rf_protocol == NCI_RF_PROTOCOL_ISO_DEP) 209 if (rf_tech_and_mode == NCI_NFC_A_PASSIVE_POLL_MODE) 210 protocol = NFC_PROTO_ISO14443_MASK; 211 else 212 protocol = NFC_PROTO_ISO14443_B_MASK; 213 else if (rf_protocol == NCI_RF_PROTOCOL_T3T) 214 protocol = NFC_PROTO_FELICA_MASK; 215 else if (rf_protocol == NCI_RF_PROTOCOL_NFC_DEP) 216 protocol = NFC_PROTO_NFC_DEP_MASK; 217 else if (rf_protocol == NCI_RF_PROTOCOL_T5T) 218 protocol = NFC_PROTO_ISO15693_MASK; 219 else 220 protocol = nci_get_prop_rf_protocol(ndev, rf_protocol); 221 222 if (!(protocol & ndev->poll_prots)) { 223 pr_err("the target found does not have the desired protocol\n"); 224 return -EPROTO; 225 } 226 227 if (rf_tech_and_mode == NCI_NFC_A_PASSIVE_POLL_MODE) { 228 nfca_poll = (struct rf_tech_specific_params_nfca_poll *)params; 229 230 target->sens_res = nfca_poll->sens_res; 231 target->sel_res = nfca_poll->sel_res; 232 target->nfcid1_len = nfca_poll->nfcid1_len; 233 if (target->nfcid1_len > 0) { 234 memcpy(target->nfcid1, nfca_poll->nfcid1, 235 target->nfcid1_len); 236 } 237 } else if (rf_tech_and_mode == NCI_NFC_B_PASSIVE_POLL_MODE) { 238 nfcb_poll = (struct rf_tech_specific_params_nfcb_poll *)params; 239 240 target->sensb_res_len = nfcb_poll->sensb_res_len; 241 if (target->sensb_res_len > 0) { 242 memcpy(target->sensb_res, nfcb_poll->sensb_res, 243 target->sensb_res_len); 244 } 245 } else if (rf_tech_and_mode == NCI_NFC_F_PASSIVE_POLL_MODE) { 246 nfcf_poll = (struct rf_tech_specific_params_nfcf_poll *)params; 247 248 target->sensf_res_len = nfcf_poll->sensf_res_len; 249 if (target->sensf_res_len > 0) { 250 memcpy(target->sensf_res, nfcf_poll->sensf_res, 251 target->sensf_res_len); 252 } 253 } else if (rf_tech_and_mode == NCI_NFC_V_PASSIVE_POLL_MODE) { 254 nfcv_poll = (struct rf_tech_specific_params_nfcv_poll *)params; 255 256 target->is_iso15693 = 1; 257 target->iso15693_dsfid = nfcv_poll->dsfid; 258 memcpy(target->iso15693_uid, nfcv_poll->uid, NFC_ISO15693_UID_MAXSIZE); 259 } else { 260 pr_err("unsupported rf_tech_and_mode 0x%x\n", rf_tech_and_mode); 261 return -EPROTO; 262 } 263 264 target->supported_protocols |= protocol; 265 266 pr_debug("protocol 0x%x\n", protocol); 267 268 return 0; 269 } 270 271 static void nci_add_new_target(struct nci_dev *ndev, 272 struct nci_rf_discover_ntf *ntf) 273 { 274 struct nfc_target *target; 275 int i, rc; 276 277 for (i = 0; i < ndev->n_targets; i++) { 278 target = &ndev->targets[i]; 279 if (target->logical_idx == ntf->rf_discovery_id) { 280 /* This target already exists, add the new protocol */ 281 nci_add_new_protocol(ndev, target, ntf->rf_protocol, 282 ntf->rf_tech_and_mode, 283 &ntf->rf_tech_specific_params); 284 return; 285 } 286 } 287 288 /* This is a new target, check if we've enough room */ 289 if (ndev->n_targets == NCI_MAX_DISCOVERED_TARGETS) { 290 pr_debug("not enough room, ignoring new target...\n"); 291 return; 292 } 293 294 target = &ndev->targets[ndev->n_targets]; 295 296 rc = nci_add_new_protocol(ndev, target, ntf->rf_protocol, 297 ntf->rf_tech_and_mode, 298 &ntf->rf_tech_specific_params); 299 if (!rc) { 300 target->logical_idx = ntf->rf_discovery_id; 301 ndev->n_targets++; 302 303 pr_debug("logical idx %d, n_targets %d\n", target->logical_idx, 304 ndev->n_targets); 305 } 306 } 307 308 void nci_clear_target_list(struct nci_dev *ndev) 309 { 310 memset(ndev->targets, 0, 311 (sizeof(struct nfc_target)*NCI_MAX_DISCOVERED_TARGETS)); 312 313 ndev->n_targets = 0; 314 } 315 316 static void nci_rf_discover_ntf_packet(struct nci_dev *ndev, 317 struct sk_buff *skb) 318 { 319 struct nci_rf_discover_ntf ntf; 320 __u8 *data = skb->data; 321 bool add_target = true; 322 323 ntf.rf_discovery_id = *data++; 324 ntf.rf_protocol = *data++; 325 ntf.rf_tech_and_mode = *data++; 326 ntf.rf_tech_specific_params_len = *data++; 327 328 pr_debug("rf_discovery_id %d\n", ntf.rf_discovery_id); 329 pr_debug("rf_protocol 0x%x\n", ntf.rf_protocol); 330 pr_debug("rf_tech_and_mode 0x%x\n", ntf.rf_tech_and_mode); 331 pr_debug("rf_tech_specific_params_len %d\n", 332 ntf.rf_tech_specific_params_len); 333 334 if (ntf.rf_tech_specific_params_len > 0) { 335 switch (ntf.rf_tech_and_mode) { 336 case NCI_NFC_A_PASSIVE_POLL_MODE: 337 data = nci_extract_rf_params_nfca_passive_poll(ndev, 338 &(ntf.rf_tech_specific_params.nfca_poll), data); 339 break; 340 341 case NCI_NFC_B_PASSIVE_POLL_MODE: 342 data = nci_extract_rf_params_nfcb_passive_poll(ndev, 343 &(ntf.rf_tech_specific_params.nfcb_poll), data); 344 break; 345 346 case NCI_NFC_F_PASSIVE_POLL_MODE: 347 data = nci_extract_rf_params_nfcf_passive_poll(ndev, 348 &(ntf.rf_tech_specific_params.nfcf_poll), data); 349 break; 350 351 case NCI_NFC_V_PASSIVE_POLL_MODE: 352 data = nci_extract_rf_params_nfcv_passive_poll(ndev, 353 &(ntf.rf_tech_specific_params.nfcv_poll), data); 354 break; 355 356 default: 357 pr_err("unsupported rf_tech_and_mode 0x%x\n", 358 ntf.rf_tech_and_mode); 359 data += ntf.rf_tech_specific_params_len; 360 add_target = false; 361 } 362 } 363 364 ntf.ntf_type = *data++; 365 pr_debug("ntf_type %d\n", ntf.ntf_type); 366 367 if (add_target == true) 368 nci_add_new_target(ndev, &ntf); 369 370 if (ntf.ntf_type == NCI_DISCOVER_NTF_TYPE_MORE) { 371 atomic_set(&ndev->state, NCI_W4_ALL_DISCOVERIES); 372 } else { 373 atomic_set(&ndev->state, NCI_W4_HOST_SELECT); 374 nfc_targets_found(ndev->nfc_dev, ndev->targets, 375 ndev->n_targets); 376 } 377 } 378 379 static int nci_extract_activation_params_iso_dep(struct nci_dev *ndev, 380 struct nci_rf_intf_activated_ntf *ntf, __u8 *data) 381 { 382 struct activation_params_nfca_poll_iso_dep *nfca_poll; 383 struct activation_params_nfcb_poll_iso_dep *nfcb_poll; 384 385 switch (ntf->activation_rf_tech_and_mode) { 386 case NCI_NFC_A_PASSIVE_POLL_MODE: 387 nfca_poll = &ntf->activation_params.nfca_poll_iso_dep; 388 nfca_poll->rats_res_len = min_t(__u8, *data++, 20); 389 pr_debug("rats_res_len %d\n", nfca_poll->rats_res_len); 390 if (nfca_poll->rats_res_len > 0) { 391 memcpy(nfca_poll->rats_res, 392 data, nfca_poll->rats_res_len); 393 } 394 break; 395 396 case NCI_NFC_B_PASSIVE_POLL_MODE: 397 nfcb_poll = &ntf->activation_params.nfcb_poll_iso_dep; 398 nfcb_poll->attrib_res_len = min_t(__u8, *data++, 50); 399 pr_debug("attrib_res_len %d\n", nfcb_poll->attrib_res_len); 400 if (nfcb_poll->attrib_res_len > 0) { 401 memcpy(nfcb_poll->attrib_res, 402 data, nfcb_poll->attrib_res_len); 403 } 404 break; 405 406 default: 407 pr_err("unsupported activation_rf_tech_and_mode 0x%x\n", 408 ntf->activation_rf_tech_and_mode); 409 return NCI_STATUS_RF_PROTOCOL_ERROR; 410 } 411 412 return NCI_STATUS_OK; 413 } 414 415 static int nci_extract_activation_params_nfc_dep(struct nci_dev *ndev, 416 struct nci_rf_intf_activated_ntf *ntf, __u8 *data) 417 { 418 struct activation_params_poll_nfc_dep *poll; 419 struct activation_params_listen_nfc_dep *listen; 420 421 switch (ntf->activation_rf_tech_and_mode) { 422 case NCI_NFC_A_PASSIVE_POLL_MODE: 423 case NCI_NFC_F_PASSIVE_POLL_MODE: 424 poll = &ntf->activation_params.poll_nfc_dep; 425 poll->atr_res_len = min_t(__u8, *data++, 426 NFC_ATR_RES_MAXSIZE - 2); 427 pr_debug("atr_res_len %d\n", poll->atr_res_len); 428 if (poll->atr_res_len > 0) 429 memcpy(poll->atr_res, data, poll->atr_res_len); 430 break; 431 432 case NCI_NFC_A_PASSIVE_LISTEN_MODE: 433 case NCI_NFC_F_PASSIVE_LISTEN_MODE: 434 listen = &ntf->activation_params.listen_nfc_dep; 435 listen->atr_req_len = min_t(__u8, *data++, 436 NFC_ATR_REQ_MAXSIZE - 2); 437 pr_debug("atr_req_len %d\n", listen->atr_req_len); 438 if (listen->atr_req_len > 0) 439 memcpy(listen->atr_req, data, listen->atr_req_len); 440 break; 441 442 default: 443 pr_err("unsupported activation_rf_tech_and_mode 0x%x\n", 444 ntf->activation_rf_tech_and_mode); 445 return NCI_STATUS_RF_PROTOCOL_ERROR; 446 } 447 448 return NCI_STATUS_OK; 449 } 450 451 static void nci_target_auto_activated(struct nci_dev *ndev, 452 struct nci_rf_intf_activated_ntf *ntf) 453 { 454 struct nfc_target *target; 455 int rc; 456 457 target = &ndev->targets[ndev->n_targets]; 458 459 rc = nci_add_new_protocol(ndev, target, ntf->rf_protocol, 460 ntf->activation_rf_tech_and_mode, 461 &ntf->rf_tech_specific_params); 462 if (rc) 463 return; 464 465 target->logical_idx = ntf->rf_discovery_id; 466 ndev->n_targets++; 467 468 pr_debug("logical idx %d, n_targets %d\n", 469 target->logical_idx, ndev->n_targets); 470 471 nfc_targets_found(ndev->nfc_dev, ndev->targets, ndev->n_targets); 472 } 473 474 static int nci_store_general_bytes_nfc_dep(struct nci_dev *ndev, 475 struct nci_rf_intf_activated_ntf *ntf) 476 { 477 ndev->remote_gb_len = 0; 478 479 if (ntf->activation_params_len <= 0) 480 return NCI_STATUS_OK; 481 482 switch (ntf->activation_rf_tech_and_mode) { 483 case NCI_NFC_A_PASSIVE_POLL_MODE: 484 case NCI_NFC_F_PASSIVE_POLL_MODE: 485 ndev->remote_gb_len = min_t(__u8, 486 (ntf->activation_params.poll_nfc_dep.atr_res_len 487 - NFC_ATR_RES_GT_OFFSET), 488 NFC_ATR_RES_GB_MAXSIZE); 489 memcpy(ndev->remote_gb, 490 (ntf->activation_params.poll_nfc_dep.atr_res 491 + NFC_ATR_RES_GT_OFFSET), 492 ndev->remote_gb_len); 493 break; 494 495 case NCI_NFC_A_PASSIVE_LISTEN_MODE: 496 case NCI_NFC_F_PASSIVE_LISTEN_MODE: 497 ndev->remote_gb_len = min_t(__u8, 498 (ntf->activation_params.listen_nfc_dep.atr_req_len 499 - NFC_ATR_REQ_GT_OFFSET), 500 NFC_ATR_REQ_GB_MAXSIZE); 501 memcpy(ndev->remote_gb, 502 (ntf->activation_params.listen_nfc_dep.atr_req 503 + NFC_ATR_REQ_GT_OFFSET), 504 ndev->remote_gb_len); 505 break; 506 507 default: 508 pr_err("unsupported activation_rf_tech_and_mode 0x%x\n", 509 ntf->activation_rf_tech_and_mode); 510 return NCI_STATUS_RF_PROTOCOL_ERROR; 511 } 512 513 return NCI_STATUS_OK; 514 } 515 516 static void nci_rf_intf_activated_ntf_packet(struct nci_dev *ndev, 517 struct sk_buff *skb) 518 { 519 struct nci_conn_info *conn_info; 520 struct nci_rf_intf_activated_ntf ntf; 521 __u8 *data = skb->data; 522 int err = NCI_STATUS_OK; 523 524 ntf.rf_discovery_id = *data++; 525 ntf.rf_interface = *data++; 526 ntf.rf_protocol = *data++; 527 ntf.activation_rf_tech_and_mode = *data++; 528 ntf.max_data_pkt_payload_size = *data++; 529 ntf.initial_num_credits = *data++; 530 ntf.rf_tech_specific_params_len = *data++; 531 532 pr_debug("rf_discovery_id %d\n", ntf.rf_discovery_id); 533 pr_debug("rf_interface 0x%x\n", ntf.rf_interface); 534 pr_debug("rf_protocol 0x%x\n", ntf.rf_protocol); 535 pr_debug("activation_rf_tech_and_mode 0x%x\n", 536 ntf.activation_rf_tech_and_mode); 537 pr_debug("max_data_pkt_payload_size 0x%x\n", 538 ntf.max_data_pkt_payload_size); 539 pr_debug("initial_num_credits 0x%x\n", 540 ntf.initial_num_credits); 541 pr_debug("rf_tech_specific_params_len %d\n", 542 ntf.rf_tech_specific_params_len); 543 544 /* If this contains a value of 0x00 (NFCEE Direct RF 545 * Interface) then all following parameters SHALL contain a 546 * value of 0 and SHALL be ignored. 547 */ 548 if (ntf.rf_interface == NCI_RF_INTERFACE_NFCEE_DIRECT) 549 goto listen; 550 551 if (ntf.rf_tech_specific_params_len > 0) { 552 switch (ntf.activation_rf_tech_and_mode) { 553 case NCI_NFC_A_PASSIVE_POLL_MODE: 554 data = nci_extract_rf_params_nfca_passive_poll(ndev, 555 &(ntf.rf_tech_specific_params.nfca_poll), data); 556 break; 557 558 case NCI_NFC_B_PASSIVE_POLL_MODE: 559 data = nci_extract_rf_params_nfcb_passive_poll(ndev, 560 &(ntf.rf_tech_specific_params.nfcb_poll), data); 561 break; 562 563 case NCI_NFC_F_PASSIVE_POLL_MODE: 564 data = nci_extract_rf_params_nfcf_passive_poll(ndev, 565 &(ntf.rf_tech_specific_params.nfcf_poll), data); 566 break; 567 568 case NCI_NFC_V_PASSIVE_POLL_MODE: 569 data = nci_extract_rf_params_nfcv_passive_poll(ndev, 570 &(ntf.rf_tech_specific_params.nfcv_poll), data); 571 break; 572 573 case NCI_NFC_A_PASSIVE_LISTEN_MODE: 574 /* no RF technology specific parameters */ 575 break; 576 577 case NCI_NFC_F_PASSIVE_LISTEN_MODE: 578 data = nci_extract_rf_params_nfcf_passive_listen(ndev, 579 &(ntf.rf_tech_specific_params.nfcf_listen), 580 data); 581 break; 582 583 default: 584 pr_err("unsupported activation_rf_tech_and_mode 0x%x\n", 585 ntf.activation_rf_tech_and_mode); 586 err = NCI_STATUS_RF_PROTOCOL_ERROR; 587 goto exit; 588 } 589 } 590 591 ntf.data_exch_rf_tech_and_mode = *data++; 592 ntf.data_exch_tx_bit_rate = *data++; 593 ntf.data_exch_rx_bit_rate = *data++; 594 ntf.activation_params_len = *data++; 595 596 pr_debug("data_exch_rf_tech_and_mode 0x%x\n", 597 ntf.data_exch_rf_tech_and_mode); 598 pr_debug("data_exch_tx_bit_rate 0x%x\n", ntf.data_exch_tx_bit_rate); 599 pr_debug("data_exch_rx_bit_rate 0x%x\n", ntf.data_exch_rx_bit_rate); 600 pr_debug("activation_params_len %d\n", ntf.activation_params_len); 601 602 if (ntf.activation_params_len > 0) { 603 switch (ntf.rf_interface) { 604 case NCI_RF_INTERFACE_ISO_DEP: 605 err = nci_extract_activation_params_iso_dep(ndev, 606 &ntf, data); 607 break; 608 609 case NCI_RF_INTERFACE_NFC_DEP: 610 err = nci_extract_activation_params_nfc_dep(ndev, 611 &ntf, data); 612 break; 613 614 case NCI_RF_INTERFACE_FRAME: 615 /* no activation params */ 616 break; 617 618 default: 619 pr_err("unsupported rf_interface 0x%x\n", 620 ntf.rf_interface); 621 err = NCI_STATUS_RF_PROTOCOL_ERROR; 622 break; 623 } 624 } 625 626 exit: 627 if (err == NCI_STATUS_OK) { 628 conn_info = ndev->rf_conn_info; 629 if (!conn_info) 630 return; 631 632 conn_info->max_pkt_payload_len = ntf.max_data_pkt_payload_size; 633 conn_info->initial_num_credits = ntf.initial_num_credits; 634 635 /* set the available credits to initial value */ 636 atomic_set(&conn_info->credits_cnt, 637 conn_info->initial_num_credits); 638 639 /* store general bytes to be reported later in dep_link_up */ 640 if (ntf.rf_interface == NCI_RF_INTERFACE_NFC_DEP) { 641 err = nci_store_general_bytes_nfc_dep(ndev, &ntf); 642 if (err != NCI_STATUS_OK) 643 pr_err("unable to store general bytes\n"); 644 } 645 } 646 647 if (!(ntf.activation_rf_tech_and_mode & NCI_RF_TECH_MODE_LISTEN_MASK)) { 648 /* Poll mode */ 649 if (atomic_read(&ndev->state) == NCI_DISCOVERY) { 650 /* A single target was found and activated 651 * automatically */ 652 atomic_set(&ndev->state, NCI_POLL_ACTIVE); 653 if (err == NCI_STATUS_OK) 654 nci_target_auto_activated(ndev, &ntf); 655 } else { /* ndev->state == NCI_W4_HOST_SELECT */ 656 /* A selected target was activated, so complete the 657 * request */ 658 atomic_set(&ndev->state, NCI_POLL_ACTIVE); 659 nci_req_complete(ndev, err); 660 } 661 } else { 662 listen: 663 /* Listen mode */ 664 atomic_set(&ndev->state, NCI_LISTEN_ACTIVE); 665 if (err == NCI_STATUS_OK && 666 ntf.rf_protocol == NCI_RF_PROTOCOL_NFC_DEP) { 667 err = nfc_tm_activated(ndev->nfc_dev, 668 NFC_PROTO_NFC_DEP_MASK, 669 NFC_COMM_PASSIVE, 670 ndev->remote_gb, 671 ndev->remote_gb_len); 672 if (err != NCI_STATUS_OK) 673 pr_err("error when signaling tm activation\n"); 674 } 675 } 676 } 677 678 static void nci_rf_deactivate_ntf_packet(struct nci_dev *ndev, 679 struct sk_buff *skb) 680 { 681 struct nci_conn_info *conn_info; 682 struct nci_rf_deactivate_ntf *ntf = (void *) skb->data; 683 684 pr_debug("entry, type 0x%x, reason 0x%x\n", ntf->type, ntf->reason); 685 686 conn_info = ndev->rf_conn_info; 687 if (!conn_info) 688 return; 689 690 /* drop tx data queue */ 691 skb_queue_purge(&ndev->tx_q); 692 693 /* drop partial rx data packet */ 694 if (ndev->rx_data_reassembly) { 695 kfree_skb(ndev->rx_data_reassembly); 696 ndev->rx_data_reassembly = NULL; 697 } 698 699 /* complete the data exchange transaction, if exists */ 700 if (test_bit(NCI_DATA_EXCHANGE, &ndev->flags)) 701 nci_data_exchange_complete(ndev, NULL, NCI_STATIC_RF_CONN_ID, 702 -EIO); 703 704 switch (ntf->type) { 705 case NCI_DEACTIVATE_TYPE_IDLE_MODE: 706 nci_clear_target_list(ndev); 707 atomic_set(&ndev->state, NCI_IDLE); 708 break; 709 case NCI_DEACTIVATE_TYPE_SLEEP_MODE: 710 case NCI_DEACTIVATE_TYPE_SLEEP_AF_MODE: 711 atomic_set(&ndev->state, NCI_W4_HOST_SELECT); 712 break; 713 case NCI_DEACTIVATE_TYPE_DISCOVERY: 714 nci_clear_target_list(ndev); 715 atomic_set(&ndev->state, NCI_DISCOVERY); 716 break; 717 } 718 719 nci_req_complete(ndev, NCI_STATUS_OK); 720 } 721 722 static void nci_nfcee_discover_ntf_packet(struct nci_dev *ndev, 723 struct sk_buff *skb) 724 { 725 u8 status = NCI_STATUS_OK; 726 struct nci_nfcee_discover_ntf *nfcee_ntf = 727 (struct nci_nfcee_discover_ntf *)skb->data; 728 729 pr_debug("\n"); 730 731 /* NFCForum NCI 9.2.1 HCI Network Specific Handling 732 * If the NFCC supports the HCI Network, it SHALL return one, 733 * and only one, NFCEE_DISCOVER_NTF with a Protocol type of 734 * “HCI Access”, even if the HCI Network contains multiple NFCEEs. 735 */ 736 ndev->hci_dev->nfcee_id = nfcee_ntf->nfcee_id; 737 ndev->cur_params.id = nfcee_ntf->nfcee_id; 738 739 nci_req_complete(ndev, status); 740 } 741 742 static void nci_nfcee_action_ntf_packet(struct nci_dev *ndev, 743 struct sk_buff *skb) 744 { 745 pr_debug("\n"); 746 } 747 748 void nci_ntf_packet(struct nci_dev *ndev, struct sk_buff *skb) 749 { 750 __u16 ntf_opcode = nci_opcode(skb->data); 751 752 pr_debug("NCI RX: MT=ntf, PBF=%d, GID=0x%x, OID=0x%x, plen=%d\n", 753 nci_pbf(skb->data), 754 nci_opcode_gid(ntf_opcode), 755 nci_opcode_oid(ntf_opcode), 756 nci_plen(skb->data)); 757 758 /* strip the nci control header */ 759 skb_pull(skb, NCI_CTRL_HDR_SIZE); 760 761 if (nci_opcode_gid(ntf_opcode) == NCI_GID_PROPRIETARY) { 762 if (nci_prop_ntf_packet(ndev, ntf_opcode, skb) == -ENOTSUPP) { 763 pr_err("unsupported ntf opcode 0x%x\n", 764 ntf_opcode); 765 } 766 767 goto end; 768 } 769 770 switch (ntf_opcode) { 771 case NCI_OP_CORE_CONN_CREDITS_NTF: 772 nci_core_conn_credits_ntf_packet(ndev, skb); 773 break; 774 775 case NCI_OP_CORE_GENERIC_ERROR_NTF: 776 nci_core_generic_error_ntf_packet(ndev, skb); 777 break; 778 779 case NCI_OP_CORE_INTF_ERROR_NTF: 780 nci_core_conn_intf_error_ntf_packet(ndev, skb); 781 break; 782 783 case NCI_OP_RF_DISCOVER_NTF: 784 nci_rf_discover_ntf_packet(ndev, skb); 785 break; 786 787 case NCI_OP_RF_INTF_ACTIVATED_NTF: 788 nci_rf_intf_activated_ntf_packet(ndev, skb); 789 break; 790 791 case NCI_OP_RF_DEACTIVATE_NTF: 792 nci_rf_deactivate_ntf_packet(ndev, skb); 793 break; 794 795 case NCI_OP_NFCEE_DISCOVER_NTF: 796 nci_nfcee_discover_ntf_packet(ndev, skb); 797 break; 798 799 case NCI_OP_RF_NFCEE_ACTION_NTF: 800 nci_nfcee_action_ntf_packet(ndev, skb); 801 break; 802 803 default: 804 pr_err("unknown ntf opcode 0x%x\n", ntf_opcode); 805 break; 806 } 807 808 nci_core_ntf_packet(ndev, ntf_opcode, skb); 809 end: 810 kfree_skb(skb); 811 } 812