net/nfc/digital_dep.c

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