1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * NFC Digital Protocol stack 4 * Copyright (c) 2013, Intel Corporation. 5 */ 6 7 #define pr_fmt(fmt) "digital: %s: " fmt, __func__ 8 9 #include "digital.h" 10 11 #define DIGITAL_NFC_DEP_N_RETRY_NACK 2 12 #define DIGITAL_NFC_DEP_N_RETRY_ATN 2 13 14 #define DIGITAL_NFC_DEP_FRAME_DIR_OUT 0xD4 15 #define DIGITAL_NFC_DEP_FRAME_DIR_IN 0xD5 16 17 #define DIGITAL_NFC_DEP_NFCA_SOD_SB 0xF0 18 19 #define DIGITAL_CMD_ATR_REQ 0x00 20 #define DIGITAL_CMD_ATR_RES 0x01 21 #define DIGITAL_CMD_PSL_REQ 0x04 22 #define DIGITAL_CMD_PSL_RES 0x05 23 #define DIGITAL_CMD_DEP_REQ 0x06 24 #define DIGITAL_CMD_DEP_RES 0x07 25 26 #define DIGITAL_ATR_REQ_MIN_SIZE 16 27 #define DIGITAL_ATR_REQ_MAX_SIZE 64 28 29 #define DIGITAL_ATR_RES_TO_WT(s) ((s) & 0xF) 30 31 #define DIGITAL_DID_MAX 14 32 33 #define DIGITAL_PAYLOAD_SIZE_MAX 254 34 #define DIGITAL_PAYLOAD_BITS_TO_PP(s) (((s) & 0x3) << 4) 35 #define DIGITAL_PAYLOAD_PP_TO_BITS(s) (((s) >> 4) & 0x3) 36 #define DIGITAL_PAYLOAD_BITS_TO_FSL(s) ((s) & 0x3) 37 #define DIGITAL_PAYLOAD_FSL_TO_BITS(s) ((s) & 0x3) 38 39 #define DIGITAL_GB_BIT 0x02 40 41 #define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0) 42 43 #define DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT 0x10 44 #define DIGITAL_NFC_DEP_PFB_MI_BIT 0x10 45 #define DIGITAL_NFC_DEP_PFB_NACK_BIT 0x10 46 #define DIGITAL_NFC_DEP_PFB_DID_BIT 0x04 47 48 #define DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb) \ 49 ((pfb) & DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT) 50 #define DIGITAL_NFC_DEP_MI_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_MI_BIT) 51 #define DIGITAL_NFC_DEP_NACK_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_NACK_BIT) 52 #define DIGITAL_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08) 53 #define DIGITAL_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_DID_BIT) 54 #define DIGITAL_NFC_DEP_PFB_PNI(pfb) ((pfb) & 0x03) 55 56 #define DIGITAL_NFC_DEP_RTOX_VALUE(data) ((data) & 0x3F) 57 #define DIGITAL_NFC_DEP_RTOX_MAX 59 58 59 #define DIGITAL_NFC_DEP_PFB_I_PDU 0x00 60 #define DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU 0x40 61 #define DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU 0x80 62 63 struct digital_atr_req { 64 u8 dir; 65 u8 cmd; 66 u8 nfcid3[10]; 67 u8 did; 68 u8 bs; 69 u8 br; 70 u8 pp; 71 u8 gb[]; 72 } __packed; 73 74 struct digital_atr_res { 75 u8 dir; 76 u8 cmd; 77 u8 nfcid3[10]; 78 u8 did; 79 u8 bs; 80 u8 br; 81 u8 to; 82 u8 pp; 83 u8 gb[]; 84 } __packed; 85 86 struct digital_psl_req { 87 u8 dir; 88 u8 cmd; 89 u8 did; 90 u8 brs; 91 u8 fsl; 92 } __packed; 93 94 struct digital_psl_res { 95 u8 dir; 96 u8 cmd; 97 u8 did; 98 } __packed; 99 100 struct digital_dep_req_res { 101 u8 dir; 102 u8 cmd; 103 u8 pfb; 104 } __packed; 105 106 static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg, 107 struct sk_buff *resp); 108 static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg, 109 struct sk_buff *resp); 110 111 static const u8 digital_payload_bits_map[4] = { 112 [0] = 64, 113 [1] = 128, 114 [2] = 192, 115 [3] = 254 116 }; 117 118 /* Response Waiting Time for ATR_RES PDU in ms 119 * 120 * RWT(ATR_RES) = RWT(nfcdep,activation) + dRWT(nfcdep) + dT(nfcdep,initiator) 121 * 122 * with: 123 * RWT(nfcdep,activation) = 4096 * 2^12 / f(c) s 124 * dRWT(nfcdep) = 16 / f(c) s 125 * dT(nfcdep,initiator) = 100 ms 126 * f(c) = 13560000 Hz 127 */ 128 #define DIGITAL_ATR_RES_RWT 1337 129 130 /* Response Waiting Time for other DEP PDUs in ms 131 * 132 * max_rwt = rwt + dRWT(nfcdep) + dT(nfcdep,initiator) 133 * 134 * with: 135 * rwt = (256 * 16 / f(c)) * 2^wt s 136 * dRWT(nfcdep) = 16 / f(c) s 137 * dT(nfcdep,initiator) = 100 ms 138 * f(c) = 13560000 Hz 139 * 0 <= wt <= 14 (given by the target by the TO field of ATR_RES response) 140 */ 141 #define DIGITAL_NFC_DEP_IN_MAX_WT 14 142 #define DIGITAL_NFC_DEP_TG_MAX_WT 14 143 static const u16 digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT + 1] = { 144 100, 101, 101, 102, 105, 145 110, 119, 139, 177, 255, 146 409, 719, 1337, 2575, 5049, 147 }; 148 149 static u8 digital_payload_bits_to_size(u8 payload_bits) 150 { 151 if (payload_bits >= ARRAY_SIZE(digital_payload_bits_map)) 152 return 0; 153 154 return digital_payload_bits_map[payload_bits]; 155 } 156 157 static u8 digital_payload_size_to_bits(u8 payload_size) 158 { 159 int i; 160 161 for (i = 0; i < ARRAY_SIZE(digital_payload_bits_map); i++) 162 if (digital_payload_bits_map[i] == payload_size) 163 return i; 164 165 return 0xff; 166 } 167 168 static void digital_skb_push_dep_sod(struct nfc_digital_dev *ddev, 169 struct sk_buff *skb) 170 { 171 skb_push(skb, sizeof(u8)); 172 173 skb->data[0] = skb->len; 174 175 if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A) 176 *(u8 *)skb_push(skb, sizeof(u8)) = DIGITAL_NFC_DEP_NFCA_SOD_SB; 177 } 178 179 static int digital_skb_pull_dep_sod(struct nfc_digital_dev *ddev, 180 struct sk_buff *skb) 181 { 182 u8 size; 183 184 if (skb->len < 2) 185 return -EIO; 186 187 if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A) 188 skb_pull(skb, sizeof(u8)); 189 190 size = skb->data[0]; 191 if (size != skb->len) 192 return -EIO; 193 194 skb_pull(skb, sizeof(u8)); 195 196 return 0; 197 } 198 199 static struct sk_buff * 200 digital_send_dep_data_prep(struct nfc_digital_dev *ddev, struct sk_buff *skb, 201 struct digital_dep_req_res *dep_req_res, 202 struct digital_data_exch *data_exch) 203 { 204 struct sk_buff *new_skb; 205 206 if (skb->len > ddev->remote_payload_max) { 207 dep_req_res->pfb |= DIGITAL_NFC_DEP_PFB_MI_BIT; 208 209 new_skb = digital_skb_alloc(ddev, ddev->remote_payload_max); 210 if (!new_skb) { 211 kfree_skb(ddev->chaining_skb); 212 ddev->chaining_skb = NULL; 213 214 return ERR_PTR(-ENOMEM); 215 } 216 217 skb_put_data(new_skb, skb->data, ddev->remote_payload_max); 218 skb_pull(skb, ddev->remote_payload_max); 219 220 ddev->chaining_skb = skb; 221 ddev->data_exch = data_exch; 222 } else { 223 ddev->chaining_skb = NULL; 224 new_skb = skb; 225 } 226 227 return new_skb; 228 } 229 230 static struct sk_buff * 231 digital_recv_dep_data_gather(struct nfc_digital_dev *ddev, u8 pfb, 232 struct sk_buff *resp, 233 int (*send_ack)(struct nfc_digital_dev *ddev, 234 struct digital_data_exch 235 *data_exch), 236 struct digital_data_exch *data_exch) 237 { 238 struct sk_buff *new_skb; 239 int rc; 240 241 if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb) && (!ddev->chaining_skb)) { 242 ddev->chaining_skb = 243 nfc_alloc_recv_skb(8 * ddev->local_payload_max, 244 GFP_KERNEL); 245 if (!ddev->chaining_skb) { 246 rc = -ENOMEM; 247 goto error; 248 } 249 } 250 251 if (ddev->chaining_skb) { 252 if (resp->len > skb_tailroom(ddev->chaining_skb)) { 253 new_skb = skb_copy_expand(ddev->chaining_skb, 254 skb_headroom( 255 ddev->chaining_skb), 256 8 * ddev->local_payload_max, 257 GFP_KERNEL); 258 if (!new_skb) { 259 rc = -ENOMEM; 260 goto error; 261 } 262 263 kfree_skb(ddev->chaining_skb); 264 ddev->chaining_skb = new_skb; 265 } 266 267 skb_put_data(ddev->chaining_skb, resp->data, resp->len); 268 269 kfree_skb(resp); 270 resp = NULL; 271 272 if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb)) { 273 rc = send_ack(ddev, data_exch); 274 if (rc) 275 goto error; 276 277 return NULL; 278 } 279 280 resp = ddev->chaining_skb; 281 ddev->chaining_skb = NULL; 282 } 283 284 return resp; 285 286 error: 287 kfree_skb(resp); 288 289 kfree_skb(ddev->chaining_skb); 290 ddev->chaining_skb = NULL; 291 292 return ERR_PTR(rc); 293 } 294 295 static void digital_in_recv_psl_res(struct nfc_digital_dev *ddev, void *arg, 296 struct sk_buff *resp) 297 { 298 struct nfc_target *target = arg; 299 struct digital_psl_res *psl_res; 300 int rc; 301 302 if (IS_ERR(resp)) { 303 rc = PTR_ERR(resp); 304 resp = NULL; 305 goto exit; 306 } 307 308 rc = ddev->skb_check_crc(resp); 309 if (rc) { 310 PROTOCOL_ERR("14.4.1.6"); 311 goto exit; 312 } 313 314 rc = digital_skb_pull_dep_sod(ddev, resp); 315 if (rc) { 316 PROTOCOL_ERR("14.4.1.2"); 317 goto exit; 318 } 319 320 psl_res = (struct digital_psl_res *)resp->data; 321 322 if ((resp->len != sizeof(*psl_res)) || 323 (psl_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN) || 324 (psl_res->cmd != DIGITAL_CMD_PSL_RES)) { 325 rc = -EIO; 326 goto exit; 327 } 328 329 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, 330 NFC_DIGITAL_RF_TECH_424F); 331 if (rc) 332 goto exit; 333 334 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, 335 NFC_DIGITAL_FRAMING_NFCF_NFC_DEP); 336 if (rc) 337 goto exit; 338 339 if (!DIGITAL_DRV_CAPS_IN_CRC(ddev) && 340 (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)) { 341 ddev->skb_add_crc = digital_skb_add_crc_f; 342 ddev->skb_check_crc = digital_skb_check_crc_f; 343 } 344 345 ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_424F; 346 347 nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE, 348 NFC_RF_INITIATOR); 349 350 ddev->curr_nfc_dep_pni = 0; 351 352 exit: 353 dev_kfree_skb(resp); 354 355 if (rc) 356 ddev->curr_protocol = 0; 357 } 358 359 static int digital_in_send_psl_req(struct nfc_digital_dev *ddev, 360 struct nfc_target *target) 361 { 362 struct sk_buff *skb; 363 struct digital_psl_req *psl_req; 364 int rc; 365 u8 payload_size, payload_bits; 366 367 skb = digital_skb_alloc(ddev, sizeof(*psl_req)); 368 if (!skb) 369 return -ENOMEM; 370 371 skb_put(skb, sizeof(*psl_req)); 372 373 psl_req = (struct digital_psl_req *)skb->data; 374 375 psl_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; 376 psl_req->cmd = DIGITAL_CMD_PSL_REQ; 377 psl_req->did = 0; 378 psl_req->brs = (0x2 << 3) | 0x2; /* 424F both directions */ 379 380 payload_size = min(ddev->local_payload_max, ddev->remote_payload_max); 381 payload_bits = digital_payload_size_to_bits(payload_size); 382 psl_req->fsl = DIGITAL_PAYLOAD_BITS_TO_FSL(payload_bits); 383 384 ddev->local_payload_max = payload_size; 385 ddev->remote_payload_max = payload_size; 386 387 digital_skb_push_dep_sod(ddev, skb); 388 389 ddev->skb_add_crc(skb); 390 391 rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt, 392 digital_in_recv_psl_res, target); 393 if (rc) 394 kfree_skb(skb); 395 396 return rc; 397 } 398 399 static void digital_in_recv_atr_res(struct nfc_digital_dev *ddev, void *arg, 400 struct sk_buff *resp) 401 { 402 struct nfc_target *target = arg; 403 struct digital_atr_res *atr_res; 404 u8 gb_len, payload_bits; 405 u8 wt; 406 int rc; 407 408 if (IS_ERR(resp)) { 409 rc = PTR_ERR(resp); 410 resp = NULL; 411 goto exit; 412 } 413 414 rc = ddev->skb_check_crc(resp); 415 if (rc) { 416 PROTOCOL_ERR("14.4.1.6"); 417 goto exit; 418 } 419 420 rc = digital_skb_pull_dep_sod(ddev, resp); 421 if (rc) { 422 PROTOCOL_ERR("14.4.1.2"); 423 goto exit; 424 } 425 426 if (resp->len < sizeof(struct digital_atr_res)) { 427 rc = -EIO; 428 goto exit; 429 } 430 431 gb_len = resp->len - sizeof(struct digital_atr_res); 432 433 atr_res = (struct digital_atr_res *)resp->data; 434 435 wt = DIGITAL_ATR_RES_TO_WT(atr_res->to); 436 if (wt > DIGITAL_NFC_DEP_IN_MAX_WT) 437 wt = DIGITAL_NFC_DEP_IN_MAX_WT; 438 ddev->dep_rwt = digital_rwt_map[wt]; 439 440 payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_res->pp); 441 ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits); 442 443 if (!ddev->remote_payload_max) { 444 rc = -EINVAL; 445 goto exit; 446 } 447 448 rc = nfc_set_remote_general_bytes(ddev->nfc_dev, atr_res->gb, gb_len); 449 if (rc) 450 goto exit; 451 452 if ((ddev->protocols & NFC_PROTO_FELICA_MASK) && 453 (ddev->curr_rf_tech != NFC_DIGITAL_RF_TECH_424F)) { 454 rc = digital_in_send_psl_req(ddev, target); 455 if (!rc) 456 goto exit; 457 } 458 459 rc = nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE, 460 NFC_RF_INITIATOR); 461 462 ddev->curr_nfc_dep_pni = 0; 463 464 exit: 465 dev_kfree_skb(resp); 466 467 if (rc) 468 ddev->curr_protocol = 0; 469 } 470 471 int digital_in_send_atr_req(struct nfc_digital_dev *ddev, 472 struct nfc_target *target, __u8 comm_mode, __u8 *gb, 473 size_t gb_len) 474 { 475 struct sk_buff *skb; 476 struct digital_atr_req *atr_req; 477 uint size; 478 int rc; 479 u8 payload_bits; 480 481 size = DIGITAL_ATR_REQ_MIN_SIZE + gb_len; 482 483 if (size > DIGITAL_ATR_REQ_MAX_SIZE) { 484 PROTOCOL_ERR("14.6.1.1"); 485 return -EINVAL; 486 } 487 488 skb = digital_skb_alloc(ddev, size); 489 if (!skb) 490 return -ENOMEM; 491 492 skb_put(skb, sizeof(struct digital_atr_req)); 493 494 atr_req = (struct digital_atr_req *)skb->data; 495 memset(atr_req, 0, sizeof(struct digital_atr_req)); 496 497 atr_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; 498 atr_req->cmd = DIGITAL_CMD_ATR_REQ; 499 if (target->nfcid2_len) 500 memcpy(atr_req->nfcid3, target->nfcid2, NFC_NFCID2_MAXSIZE); 501 else 502 get_random_bytes(atr_req->nfcid3, NFC_NFCID3_MAXSIZE); 503 504 atr_req->did = 0; 505 atr_req->bs = 0; 506 atr_req->br = 0; 507 508 ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX; 509 payload_bits = digital_payload_size_to_bits(ddev->local_payload_max); 510 atr_req->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits); 511 512 if (gb_len) { 513 atr_req->pp |= DIGITAL_GB_BIT; 514 skb_put_data(skb, gb, gb_len); 515 } 516 517 digital_skb_push_dep_sod(ddev, skb); 518 519 ddev->skb_add_crc(skb); 520 521 rc = digital_in_send_cmd(ddev, skb, DIGITAL_ATR_RES_RWT, 522 digital_in_recv_atr_res, target); 523 if (rc) 524 kfree_skb(skb); 525 526 return rc; 527 } 528 529 static int digital_in_send_ack(struct nfc_digital_dev *ddev, 530 struct digital_data_exch *data_exch) 531 { 532 struct digital_dep_req_res *dep_req; 533 struct sk_buff *skb; 534 int rc; 535 536 skb = digital_skb_alloc(ddev, 1); 537 if (!skb) 538 return -ENOMEM; 539 540 skb_push(skb, sizeof(struct digital_dep_req_res)); 541 542 dep_req = (struct digital_dep_req_res *)skb->data; 543 544 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; 545 dep_req->cmd = DIGITAL_CMD_DEP_REQ; 546 dep_req->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU | 547 ddev->curr_nfc_dep_pni; 548 549 digital_skb_push_dep_sod(ddev, skb); 550 551 ddev->skb_add_crc(skb); 552 553 ddev->saved_skb = pskb_copy(skb, GFP_KERNEL); 554 555 rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt, 556 digital_in_recv_dep_res, data_exch); 557 if (rc) { 558 kfree_skb(skb); 559 kfree_skb(ddev->saved_skb); 560 ddev->saved_skb = NULL; 561 } 562 563 return rc; 564 } 565 566 static int digital_in_send_nack(struct nfc_digital_dev *ddev, 567 struct digital_data_exch *data_exch) 568 { 569 struct digital_dep_req_res *dep_req; 570 struct sk_buff *skb; 571 int rc; 572 573 skb = digital_skb_alloc(ddev, 1); 574 if (!skb) 575 return -ENOMEM; 576 577 skb_push(skb, sizeof(struct digital_dep_req_res)); 578 579 dep_req = (struct digital_dep_req_res *)skb->data; 580 581 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; 582 dep_req->cmd = DIGITAL_CMD_DEP_REQ; 583 dep_req->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU | 584 DIGITAL_NFC_DEP_PFB_NACK_BIT | ddev->curr_nfc_dep_pni; 585 586 digital_skb_push_dep_sod(ddev, skb); 587 588 ddev->skb_add_crc(skb); 589 590 rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt, 591 digital_in_recv_dep_res, data_exch); 592 if (rc) 593 kfree_skb(skb); 594 595 return rc; 596 } 597 598 static int digital_in_send_atn(struct nfc_digital_dev *ddev, 599 struct digital_data_exch *data_exch) 600 { 601 struct digital_dep_req_res *dep_req; 602 struct sk_buff *skb; 603 int rc; 604 605 skb = digital_skb_alloc(ddev, 1); 606 if (!skb) 607 return -ENOMEM; 608 609 skb_push(skb, sizeof(struct digital_dep_req_res)); 610 611 dep_req = (struct digital_dep_req_res *)skb->data; 612 613 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; 614 dep_req->cmd = DIGITAL_CMD_DEP_REQ; 615 dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU; 616 617 digital_skb_push_dep_sod(ddev, skb); 618 619 ddev->skb_add_crc(skb); 620 621 rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt, 622 digital_in_recv_dep_res, data_exch); 623 if (rc) 624 kfree_skb(skb); 625 626 return rc; 627 } 628 629 static int digital_in_send_rtox(struct nfc_digital_dev *ddev, 630 struct digital_data_exch *data_exch, u8 rtox) 631 { 632 struct digital_dep_req_res *dep_req; 633 struct sk_buff *skb; 634 int rc; 635 u16 rwt_int; 636 637 rwt_int = ddev->dep_rwt * rtox; 638 if (rwt_int > digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT]) 639 rwt_int = digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT]; 640 641 skb = digital_skb_alloc(ddev, 1); 642 if (!skb) 643 return -ENOMEM; 644 645 skb_put_u8(skb, rtox); 646 647 skb_push(skb, sizeof(struct digital_dep_req_res)); 648 649 dep_req = (struct digital_dep_req_res *)skb->data; 650 651 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; 652 dep_req->cmd = DIGITAL_CMD_DEP_REQ; 653 dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU | 654 DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT; 655 656 digital_skb_push_dep_sod(ddev, skb); 657 658 ddev->skb_add_crc(skb); 659 660 rc = digital_in_send_cmd(ddev, skb, rwt_int, 661 digital_in_recv_dep_res, data_exch); 662 if (rc) 663 kfree_skb(skb); 664 665 return rc; 666 } 667 668 static int digital_in_send_saved_skb(struct nfc_digital_dev *ddev, 669 struct digital_data_exch *data_exch) 670 { 671 int rc; 672 673 if (!ddev->saved_skb) 674 return -EINVAL; 675 676 skb_get(ddev->saved_skb); 677 678 rc = digital_in_send_cmd(ddev, ddev->saved_skb, ddev->dep_rwt, 679 digital_in_recv_dep_res, data_exch); 680 if (rc) 681 kfree_skb(ddev->saved_skb); 682 683 return rc; 684 } 685 686 static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg, 687 struct sk_buff *resp) 688 { 689 struct digital_data_exch *data_exch = arg; 690 struct digital_dep_req_res *dep_res; 691 u8 pfb; 692 uint size; 693 int rc; 694 u8 rtox; 695 696 if (IS_ERR(resp)) { 697 rc = PTR_ERR(resp); 698 resp = NULL; 699 700 if ((rc == -EIO || (rc == -ETIMEDOUT && ddev->nack_count)) && 701 (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) { 702 ddev->atn_count = 0; 703 704 rc = digital_in_send_nack(ddev, data_exch); 705 if (rc) 706 goto error; 707 708 return; 709 } else if ((rc == -ETIMEDOUT) && 710 (ddev->atn_count++ < DIGITAL_NFC_DEP_N_RETRY_ATN)) { 711 ddev->nack_count = 0; 712 713 rc = digital_in_send_atn(ddev, data_exch); 714 if (rc) 715 goto error; 716 717 return; 718 } 719 720 goto exit; 721 } 722 723 rc = digital_skb_pull_dep_sod(ddev, resp); 724 if (rc) { 725 PROTOCOL_ERR("14.4.1.2"); 726 goto exit; 727 } 728 729 rc = ddev->skb_check_crc(resp); 730 if (rc) { 731 if ((resp->len >= 4) && 732 (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) { 733 ddev->atn_count = 0; 734 735 rc = digital_in_send_nack(ddev, data_exch); 736 if (rc) 737 goto error; 738 739 kfree_skb(resp); 740 741 return; 742 } 743 744 PROTOCOL_ERR("14.4.1.6"); 745 goto error; 746 } 747 748 ddev->atn_count = 0; 749 ddev->nack_count = 0; 750 751 if (resp->len > ddev->local_payload_max) { 752 rc = -EMSGSIZE; 753 goto exit; 754 } 755 756 size = sizeof(struct digital_dep_req_res); 757 dep_res = (struct digital_dep_req_res *)resp->data; 758 759 if (resp->len < size || dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN || 760 dep_res->cmd != DIGITAL_CMD_DEP_RES) { 761 rc = -EIO; 762 goto error; 763 } 764 765 pfb = dep_res->pfb; 766 767 if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) { 768 PROTOCOL_ERR("14.8.2.1"); 769 rc = -EIO; 770 goto error; 771 } 772 773 if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) { 774 rc = -EIO; 775 goto exit; 776 } 777 778 if (size > resp->len) { 779 rc = -EIO; 780 goto error; 781 } 782 783 skb_pull(resp, size); 784 785 switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) { 786 case DIGITAL_NFC_DEP_PFB_I_PDU: 787 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) { 788 PROTOCOL_ERR("14.12.3.3"); 789 rc = -EIO; 790 goto error; 791 } 792 793 ddev->curr_nfc_dep_pni = 794 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1); 795 796 kfree_skb(ddev->saved_skb); 797 ddev->saved_skb = NULL; 798 799 resp = digital_recv_dep_data_gather(ddev, pfb, resp, 800 digital_in_send_ack, 801 data_exch); 802 if (IS_ERR(resp)) { 803 rc = PTR_ERR(resp); 804 resp = NULL; 805 goto error; 806 } 807 808 /* If resp is NULL then we're still chaining so return and 809 * wait for the next part of the PDU. Else, the PDU is 810 * complete so pass it up. 811 */ 812 if (!resp) 813 return; 814 815 rc = 0; 816 break; 817 818 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU: 819 if (DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) { 820 PROTOCOL_ERR("14.12.4.5"); 821 rc = -EIO; 822 goto exit; 823 } 824 825 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) { 826 PROTOCOL_ERR("14.12.3.3"); 827 rc = -EIO; 828 goto exit; 829 } 830 831 ddev->curr_nfc_dep_pni = 832 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1); 833 834 if (!ddev->chaining_skb) { 835 PROTOCOL_ERR("14.12.4.3"); 836 rc = -EIO; 837 goto exit; 838 } 839 840 /* The initiator has received a valid ACK. Free the last sent 841 * PDU and keep on sending chained skb. 842 */ 843 kfree_skb(ddev->saved_skb); 844 ddev->saved_skb = NULL; 845 846 rc = digital_in_send_dep_req(ddev, NULL, 847 ddev->chaining_skb, 848 ddev->data_exch); 849 if (rc) 850 goto error; 851 852 goto free_resp; 853 854 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU: 855 if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) { /* ATN */ 856 rc = digital_in_send_saved_skb(ddev, data_exch); 857 if (rc) 858 goto error; 859 860 goto free_resp; 861 } 862 863 if (ddev->atn_count || ddev->nack_count) { 864 PROTOCOL_ERR("14.12.4.4"); 865 rc = -EIO; 866 goto error; 867 } 868 869 rtox = DIGITAL_NFC_DEP_RTOX_VALUE(resp->data[0]); 870 if (!rtox || rtox > DIGITAL_NFC_DEP_RTOX_MAX) { 871 PROTOCOL_ERR("14.8.4.1"); 872 rc = -EIO; 873 goto error; 874 } 875 876 rc = digital_in_send_rtox(ddev, data_exch, rtox); 877 if (rc) 878 goto error; 879 880 goto free_resp; 881 } 882 883 exit: 884 data_exch->cb(data_exch->cb_context, resp, rc); 885 886 error: 887 kfree(data_exch); 888 889 kfree_skb(ddev->chaining_skb); 890 ddev->chaining_skb = NULL; 891 892 kfree_skb(ddev->saved_skb); 893 ddev->saved_skb = NULL; 894 895 if (rc) 896 kfree_skb(resp); 897 898 return; 899 900 free_resp: 901 dev_kfree_skb(resp); 902 } 903 904 int digital_in_send_dep_req(struct nfc_digital_dev *ddev, 905 struct nfc_target *target, struct sk_buff *skb, 906 struct digital_data_exch *data_exch) 907 { 908 struct digital_dep_req_res *dep_req; 909 struct sk_buff *chaining_skb, *tmp_skb; 910 int rc; 911 912 skb_push(skb, sizeof(struct digital_dep_req_res)); 913 914 dep_req = (struct digital_dep_req_res *)skb->data; 915 916 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; 917 dep_req->cmd = DIGITAL_CMD_DEP_REQ; 918 dep_req->pfb = ddev->curr_nfc_dep_pni; 919 920 ddev->atn_count = 0; 921 ddev->nack_count = 0; 922 923 chaining_skb = ddev->chaining_skb; 924 925 tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_req, data_exch); 926 if (IS_ERR(tmp_skb)) 927 return PTR_ERR(tmp_skb); 928 929 digital_skb_push_dep_sod(ddev, tmp_skb); 930 931 ddev->skb_add_crc(tmp_skb); 932 933 ddev->saved_skb = pskb_copy(tmp_skb, GFP_KERNEL); 934 935 rc = digital_in_send_cmd(ddev, tmp_skb, ddev->dep_rwt, 936 digital_in_recv_dep_res, data_exch); 937 if (rc) { 938 if (tmp_skb != skb) 939 kfree_skb(tmp_skb); 940 941 kfree_skb(chaining_skb); 942 ddev->chaining_skb = NULL; 943 944 kfree_skb(ddev->saved_skb); 945 ddev->saved_skb = NULL; 946 } 947 948 return rc; 949 } 950 951 static void digital_tg_set_rf_tech(struct nfc_digital_dev *ddev, u8 rf_tech) 952 { 953 ddev->curr_rf_tech = rf_tech; 954 955 ddev->skb_add_crc = digital_skb_add_crc_none; 956 ddev->skb_check_crc = digital_skb_check_crc_none; 957 958 if (DIGITAL_DRV_CAPS_TG_CRC(ddev)) 959 return; 960 961 switch (ddev->curr_rf_tech) { 962 case NFC_DIGITAL_RF_TECH_106A: 963 ddev->skb_add_crc = digital_skb_add_crc_a; 964 ddev->skb_check_crc = digital_skb_check_crc_a; 965 break; 966 967 case NFC_DIGITAL_RF_TECH_212F: 968 case NFC_DIGITAL_RF_TECH_424F: 969 ddev->skb_add_crc = digital_skb_add_crc_f; 970 ddev->skb_check_crc = digital_skb_check_crc_f; 971 break; 972 973 default: 974 break; 975 } 976 } 977 978 static int digital_tg_send_ack(struct nfc_digital_dev *ddev, 979 struct digital_data_exch *data_exch) 980 { 981 struct digital_dep_req_res *dep_res; 982 struct sk_buff *skb; 983 int rc; 984 985 skb = digital_skb_alloc(ddev, 1); 986 if (!skb) 987 return -ENOMEM; 988 989 skb_push(skb, sizeof(struct digital_dep_req_res)); 990 991 dep_res = (struct digital_dep_req_res *)skb->data; 992 993 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN; 994 dep_res->cmd = DIGITAL_CMD_DEP_RES; 995 dep_res->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU | 996 ddev->curr_nfc_dep_pni; 997 998 if (ddev->did) { 999 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT; 1000 1001 skb_put_data(skb, &ddev->did, sizeof(ddev->did)); 1002 } 1003 1004 ddev->curr_nfc_dep_pni = 1005 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1); 1006 1007 digital_skb_push_dep_sod(ddev, skb); 1008 1009 ddev->skb_add_crc(skb); 1010 1011 ddev->saved_skb = pskb_copy(skb, GFP_KERNEL); 1012 1013 rc = digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req, 1014 data_exch); 1015 if (rc) { 1016 kfree_skb(skb); 1017 kfree_skb(ddev->saved_skb); 1018 ddev->saved_skb = NULL; 1019 } 1020 1021 return rc; 1022 } 1023 1024 static int digital_tg_send_atn(struct nfc_digital_dev *ddev) 1025 { 1026 struct digital_dep_req_res *dep_res; 1027 struct sk_buff *skb; 1028 int rc; 1029 1030 skb = digital_skb_alloc(ddev, 1); 1031 if (!skb) 1032 return -ENOMEM; 1033 1034 skb_push(skb, sizeof(struct digital_dep_req_res)); 1035 1036 dep_res = (struct digital_dep_req_res *)skb->data; 1037 1038 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN; 1039 dep_res->cmd = DIGITAL_CMD_DEP_RES; 1040 dep_res->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU; 1041 1042 if (ddev->did) { 1043 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT; 1044 1045 skb_put_data(skb, &ddev->did, sizeof(ddev->did)); 1046 } 1047 1048 digital_skb_push_dep_sod(ddev, skb); 1049 1050 ddev->skb_add_crc(skb); 1051 1052 rc = digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req, 1053 NULL); 1054 if (rc) 1055 kfree_skb(skb); 1056 1057 return rc; 1058 } 1059 1060 static int digital_tg_send_saved_skb(struct nfc_digital_dev *ddev) 1061 { 1062 int rc; 1063 1064 if (!ddev->saved_skb) 1065 return -EINVAL; 1066 1067 skb_get(ddev->saved_skb); 1068 1069 rc = digital_tg_send_cmd(ddev, ddev->saved_skb, 1500, 1070 digital_tg_recv_dep_req, NULL); 1071 if (rc) 1072 kfree_skb(ddev->saved_skb); 1073 1074 return rc; 1075 } 1076 1077 static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg, 1078 struct sk_buff *resp) 1079 { 1080 int rc; 1081 struct digital_dep_req_res *dep_req; 1082 u8 pfb; 1083 size_t size; 1084 1085 if (IS_ERR(resp)) { 1086 rc = PTR_ERR(resp); 1087 resp = NULL; 1088 goto exit; 1089 } 1090 1091 rc = ddev->skb_check_crc(resp); 1092 if (rc) { 1093 PROTOCOL_ERR("14.4.1.6"); 1094 goto exit; 1095 } 1096 1097 rc = digital_skb_pull_dep_sod(ddev, resp); 1098 if (rc) { 1099 PROTOCOL_ERR("14.4.1.2"); 1100 goto exit; 1101 } 1102 1103 if (resp->len > ddev->local_payload_max) { 1104 rc = -EMSGSIZE; 1105 goto exit; 1106 } 1107 1108 size = sizeof(struct digital_dep_req_res); 1109 dep_req = (struct digital_dep_req_res *)resp->data; 1110 1111 if (resp->len < size || dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT || 1112 dep_req->cmd != DIGITAL_CMD_DEP_REQ) { 1113 rc = -EIO; 1114 goto exit; 1115 } 1116 1117 pfb = dep_req->pfb; 1118 1119 if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) { 1120 if (ddev->did && (ddev->did == resp->data[3])) { 1121 size++; 1122 } else { 1123 rc = -EIO; 1124 goto exit; 1125 } 1126 } else if (ddev->did) { 1127 rc = -EIO; 1128 goto exit; 1129 } 1130 1131 if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) { 1132 rc = -EIO; 1133 goto exit; 1134 } 1135 1136 if (size > resp->len) { 1137 rc = -EIO; 1138 goto exit; 1139 } 1140 1141 skb_pull(resp, size); 1142 1143 switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) { 1144 case DIGITAL_NFC_DEP_PFB_I_PDU: 1145 pr_debug("DIGITAL_NFC_DEP_PFB_I_PDU\n"); 1146 1147 if (ddev->atn_count) { 1148 /* The target has received (and replied to) at least one 1149 * ATN DEP_REQ. 1150 */ 1151 ddev->atn_count = 0; 1152 1153 /* pni of resp PDU equal to the target current pni - 1 1154 * means resp is the previous DEP_REQ PDU received from 1155 * the initiator so the target replies with saved_skb 1156 * which is the previous DEP_RES saved in 1157 * digital_tg_send_dep_res(). 1158 */ 1159 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) == 1160 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni - 1)) { 1161 rc = digital_tg_send_saved_skb(ddev); 1162 if (rc) 1163 goto exit; 1164 1165 goto free_resp; 1166 } 1167 1168 /* atn_count > 0 and PDU pni != curr_nfc_dep_pni - 1 1169 * means the target probably did not received the last 1170 * DEP_REQ PDU sent by the initiator. The target 1171 * fallbacks to normal processing then. 1172 */ 1173 } 1174 1175 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) { 1176 PROTOCOL_ERR("14.12.3.4"); 1177 rc = -EIO; 1178 goto exit; 1179 } 1180 1181 kfree_skb(ddev->saved_skb); 1182 ddev->saved_skb = NULL; 1183 1184 resp = digital_recv_dep_data_gather(ddev, pfb, resp, 1185 digital_tg_send_ack, NULL); 1186 if (IS_ERR(resp)) { 1187 rc = PTR_ERR(resp); 1188 resp = NULL; 1189 goto exit; 1190 } 1191 1192 /* If resp is NULL then we're still chaining so return and 1193 * wait for the next part of the PDU. Else, the PDU is 1194 * complete so pass it up. 1195 */ 1196 if (!resp) 1197 return; 1198 1199 rc = 0; 1200 break; 1201 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU: 1202 if (DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) { /* NACK */ 1203 if (DIGITAL_NFC_DEP_PFB_PNI(pfb + 1) != 1204 ddev->curr_nfc_dep_pni) { 1205 rc = -EIO; 1206 goto exit; 1207 } 1208 1209 ddev->atn_count = 0; 1210 1211 rc = digital_tg_send_saved_skb(ddev); 1212 if (rc) 1213 goto exit; 1214 1215 goto free_resp; 1216 } 1217 1218 /* ACK */ 1219 if (ddev->atn_count) { 1220 /* The target has previously recevied one or more ATN 1221 * PDUs. 1222 */ 1223 ddev->atn_count = 0; 1224 1225 /* If the ACK PNI is equal to the target PNI - 1 means 1226 * that the initiator did not receive the previous PDU 1227 * sent by the target so re-send it. 1228 */ 1229 if (DIGITAL_NFC_DEP_PFB_PNI(pfb + 1) == 1230 ddev->curr_nfc_dep_pni) { 1231 rc = digital_tg_send_saved_skb(ddev); 1232 if (rc) 1233 goto exit; 1234 1235 goto free_resp; 1236 } 1237 1238 /* Otherwise, the target did not receive the previous 1239 * ACK PDU from the initiator. Fallback to normal 1240 * processing of chained PDU then. 1241 */ 1242 } 1243 1244 /* Keep on sending chained PDU */ 1245 if (!ddev->chaining_skb || 1246 DIGITAL_NFC_DEP_PFB_PNI(pfb) != 1247 ddev->curr_nfc_dep_pni) { 1248 rc = -EIO; 1249 goto exit; 1250 } 1251 1252 kfree_skb(ddev->saved_skb); 1253 ddev->saved_skb = NULL; 1254 1255 rc = digital_tg_send_dep_res(ddev, ddev->chaining_skb); 1256 if (rc) 1257 goto exit; 1258 1259 goto free_resp; 1260 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU: 1261 if (DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) { 1262 rc = -EINVAL; 1263 goto exit; 1264 } 1265 1266 rc = digital_tg_send_atn(ddev); 1267 if (rc) 1268 goto exit; 1269 1270 ddev->atn_count++; 1271 1272 goto free_resp; 1273 } 1274 1275 rc = nfc_tm_data_received(ddev->nfc_dev, resp); 1276 1277 exit: 1278 kfree_skb(ddev->chaining_skb); 1279 ddev->chaining_skb = NULL; 1280 1281 ddev->atn_count = 0; 1282 1283 kfree_skb(ddev->saved_skb); 1284 ddev->saved_skb = NULL; 1285 1286 if (rc) 1287 kfree_skb(resp); 1288 1289 return; 1290 1291 free_resp: 1292 dev_kfree_skb(resp); 1293 } 1294 1295 int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb) 1296 { 1297 struct digital_dep_req_res *dep_res; 1298 struct sk_buff *chaining_skb, *tmp_skb; 1299 int rc; 1300 1301 skb_push(skb, sizeof(struct digital_dep_req_res)); 1302 1303 dep_res = (struct digital_dep_req_res *)skb->data; 1304 1305 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN; 1306 dep_res->cmd = DIGITAL_CMD_DEP_RES; 1307 dep_res->pfb = ddev->curr_nfc_dep_pni; 1308 1309 if (ddev->did) { 1310 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT; 1311 1312 skb_put_data(skb, &ddev->did, sizeof(ddev->did)); 1313 } 1314 1315 ddev->curr_nfc_dep_pni = 1316 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1); 1317 1318 chaining_skb = ddev->chaining_skb; 1319 1320 tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_res, NULL); 1321 if (IS_ERR(tmp_skb)) 1322 return PTR_ERR(tmp_skb); 1323 1324 digital_skb_push_dep_sod(ddev, tmp_skb); 1325 1326 ddev->skb_add_crc(tmp_skb); 1327 1328 ddev->saved_skb = pskb_copy(tmp_skb, GFP_KERNEL); 1329 1330 rc = digital_tg_send_cmd(ddev, tmp_skb, 1500, digital_tg_recv_dep_req, 1331 NULL); 1332 if (rc) { 1333 if (tmp_skb != skb) 1334 kfree_skb(tmp_skb); 1335 1336 kfree_skb(chaining_skb); 1337 ddev->chaining_skb = NULL; 1338 1339 kfree_skb(ddev->saved_skb); 1340 ddev->saved_skb = NULL; 1341 } 1342 1343 return rc; 1344 } 1345 1346 static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev, 1347 void *arg, struct sk_buff *resp) 1348 { 1349 u8 rf_tech = (unsigned long)arg; 1350 1351 if (IS_ERR(resp)) 1352 return; 1353 1354 digital_tg_set_rf_tech(ddev, rf_tech); 1355 1356 digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech); 1357 1358 digital_tg_listen(ddev, 1500, digital_tg_recv_dep_req, NULL); 1359 1360 dev_kfree_skb(resp); 1361 } 1362 1363 static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did, 1364 u8 rf_tech) 1365 { 1366 struct digital_psl_res *psl_res; 1367 struct sk_buff *skb; 1368 int rc; 1369 1370 skb = digital_skb_alloc(ddev, sizeof(struct digital_psl_res)); 1371 if (!skb) 1372 return -ENOMEM; 1373 1374 skb_put(skb, sizeof(struct digital_psl_res)); 1375 1376 psl_res = (struct digital_psl_res *)skb->data; 1377 1378 psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN; 1379 psl_res->cmd = DIGITAL_CMD_PSL_RES; 1380 psl_res->did = did; 1381 1382 digital_skb_push_dep_sod(ddev, skb); 1383 1384 ddev->skb_add_crc(skb); 1385 1386 ddev->curr_nfc_dep_pni = 0; 1387 1388 rc = digital_tg_send_cmd(ddev, skb, 0, digital_tg_send_psl_res_complete, 1389 (void *)(unsigned long)rf_tech); 1390 if (rc) 1391 kfree_skb(skb); 1392 1393 return rc; 1394 } 1395 1396 static void digital_tg_recv_psl_req(struct nfc_digital_dev *ddev, void *arg, 1397 struct sk_buff *resp) 1398 { 1399 int rc; 1400 struct digital_psl_req *psl_req; 1401 u8 rf_tech; 1402 u8 dsi, payload_size, payload_bits; 1403 1404 if (IS_ERR(resp)) { 1405 rc = PTR_ERR(resp); 1406 resp = NULL; 1407 goto exit; 1408 } 1409 1410 rc = ddev->skb_check_crc(resp); 1411 if (rc) { 1412 PROTOCOL_ERR("14.4.1.6"); 1413 goto exit; 1414 } 1415 1416 rc = digital_skb_pull_dep_sod(ddev, resp); 1417 if (rc) { 1418 PROTOCOL_ERR("14.4.1.2"); 1419 goto exit; 1420 } 1421 1422 psl_req = (struct digital_psl_req *)resp->data; 1423 1424 if (resp->len != sizeof(struct digital_psl_req) || 1425 psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT || 1426 psl_req->cmd != DIGITAL_CMD_PSL_REQ) { 1427 rc = -EIO; 1428 goto exit; 1429 } 1430 1431 dsi = (psl_req->brs >> 3) & 0x07; 1432 switch (dsi) { 1433 case 0: 1434 rf_tech = NFC_DIGITAL_RF_TECH_106A; 1435 break; 1436 case 1: 1437 rf_tech = NFC_DIGITAL_RF_TECH_212F; 1438 break; 1439 case 2: 1440 rf_tech = NFC_DIGITAL_RF_TECH_424F; 1441 break; 1442 default: 1443 pr_err("Unsupported dsi value %d\n", dsi); 1444 goto exit; 1445 } 1446 1447 payload_bits = DIGITAL_PAYLOAD_FSL_TO_BITS(psl_req->fsl); 1448 payload_size = digital_payload_bits_to_size(payload_bits); 1449 1450 if (!payload_size || (payload_size > min(ddev->local_payload_max, 1451 ddev->remote_payload_max))) { 1452 rc = -EINVAL; 1453 goto exit; 1454 } 1455 1456 ddev->local_payload_max = payload_size; 1457 ddev->remote_payload_max = payload_size; 1458 1459 rc = digital_tg_send_psl_res(ddev, psl_req->did, rf_tech); 1460 1461 exit: 1462 kfree_skb(resp); 1463 } 1464 1465 static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev, 1466 void *arg, struct sk_buff *resp) 1467 { 1468 int offset; 1469 1470 if (IS_ERR(resp)) { 1471 digital_poll_next_tech(ddev); 1472 return; 1473 } 1474 1475 offset = 2; 1476 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) 1477 offset++; 1478 1479 ddev->atn_count = 0; 1480 1481 if (resp->data[offset] == DIGITAL_CMD_PSL_REQ) 1482 digital_tg_recv_psl_req(ddev, arg, resp); 1483 else 1484 digital_tg_recv_dep_req(ddev, arg, resp); 1485 } 1486 1487 static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev, 1488 struct digital_atr_req *atr_req) 1489 { 1490 struct digital_atr_res *atr_res; 1491 struct sk_buff *skb; 1492 u8 *gb, payload_bits; 1493 size_t gb_len; 1494 int rc; 1495 1496 gb = nfc_get_local_general_bytes(ddev->nfc_dev, &gb_len); 1497 if (!gb) 1498 gb_len = 0; 1499 1500 skb = digital_skb_alloc(ddev, sizeof(struct digital_atr_res) + gb_len); 1501 if (!skb) 1502 return -ENOMEM; 1503 1504 skb_put(skb, sizeof(struct digital_atr_res)); 1505 atr_res = (struct digital_atr_res *)skb->data; 1506 1507 memset(atr_res, 0, sizeof(struct digital_atr_res)); 1508 1509 atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN; 1510 atr_res->cmd = DIGITAL_CMD_ATR_RES; 1511 memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3)); 1512 atr_res->to = DIGITAL_NFC_DEP_TG_MAX_WT; 1513 1514 ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX; 1515 payload_bits = digital_payload_size_to_bits(ddev->local_payload_max); 1516 atr_res->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits); 1517 1518 if (gb_len) { 1519 skb_put(skb, gb_len); 1520 1521 atr_res->pp |= DIGITAL_GB_BIT; 1522 memcpy(atr_res->gb, gb, gb_len); 1523 } 1524 1525 digital_skb_push_dep_sod(ddev, skb); 1526 1527 ddev->skb_add_crc(skb); 1528 1529 ddev->curr_nfc_dep_pni = 0; 1530 1531 rc = digital_tg_send_cmd(ddev, skb, 999, 1532 digital_tg_send_atr_res_complete, NULL); 1533 if (rc) 1534 kfree_skb(skb); 1535 1536 return rc; 1537 } 1538 1539 void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg, 1540 struct sk_buff *resp) 1541 { 1542 int rc; 1543 struct digital_atr_req *atr_req; 1544 size_t gb_len, min_size; 1545 u8 poll_tech_count, payload_bits; 1546 1547 if (IS_ERR(resp)) { 1548 rc = PTR_ERR(resp); 1549 resp = NULL; 1550 goto exit; 1551 } 1552 1553 if (!resp->len) { 1554 rc = -EIO; 1555 goto exit; 1556 } 1557 1558 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) { 1559 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2; 1560 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_106A); 1561 } else { 1562 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1; 1563 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_212F); 1564 } 1565 1566 if (resp->len < min_size) { 1567 rc = -EIO; 1568 goto exit; 1569 } 1570 1571 ddev->curr_protocol = NFC_PROTO_NFC_DEP_MASK; 1572 1573 rc = ddev->skb_check_crc(resp); 1574 if (rc) { 1575 PROTOCOL_ERR("14.4.1.6"); 1576 goto exit; 1577 } 1578 1579 rc = digital_skb_pull_dep_sod(ddev, resp); 1580 if (rc) { 1581 PROTOCOL_ERR("14.4.1.2"); 1582 goto exit; 1583 } 1584 1585 atr_req = (struct digital_atr_req *)resp->data; 1586 1587 if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT || 1588 atr_req->cmd != DIGITAL_CMD_ATR_REQ || 1589 atr_req->did > DIGITAL_DID_MAX) { 1590 rc = -EINVAL; 1591 goto exit; 1592 } 1593 1594 payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_req->pp); 1595 ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits); 1596 1597 if (!ddev->remote_payload_max) { 1598 rc = -EINVAL; 1599 goto exit; 1600 } 1601 1602 ddev->did = atr_req->did; 1603 1604 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, 1605 NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED); 1606 if (rc) 1607 goto exit; 1608 1609 rc = digital_tg_send_atr_res(ddev, atr_req); 1610 if (rc) 1611 goto exit; 1612 1613 gb_len = resp->len - sizeof(struct digital_atr_req); 1614 1615 poll_tech_count = ddev->poll_tech_count; 1616 ddev->poll_tech_count = 0; 1617 1618 rc = nfc_tm_activated(ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK, 1619 NFC_COMM_PASSIVE, atr_req->gb, gb_len); 1620 if (rc) { 1621 ddev->poll_tech_count = poll_tech_count; 1622 goto exit; 1623 } 1624 1625 rc = 0; 1626 exit: 1627 if (rc) 1628 digital_poll_next_tech(ddev); 1629 1630 dev_kfree_skb(resp); 1631 } 1632