2 * NFC Digital Protocol stack
3 * Copyright (c) 2013, Intel Corporation.
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.
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
16 #define pr_fmt(fmt) "digital: %s: " fmt, __func__
20 #define DIGITAL_NFC_DEP_N_RETRY_NACK 2
22 #define DIGITAL_NFC_DEP_FRAME_DIR_OUT 0xD4
23 #define DIGITAL_NFC_DEP_FRAME_DIR_IN 0xD5
25 #define DIGITAL_NFC_DEP_NFCA_SOD_SB 0xF0
27 #define DIGITAL_CMD_ATR_REQ 0x00
28 #define DIGITAL_CMD_ATR_RES 0x01
29 #define DIGITAL_CMD_PSL_REQ 0x04
30 #define DIGITAL_CMD_PSL_RES 0x05
31 #define DIGITAL_CMD_DEP_REQ 0x06
32 #define DIGITAL_CMD_DEP_RES 0x07
34 #define DIGITAL_ATR_REQ_MIN_SIZE 16
35 #define DIGITAL_ATR_REQ_MAX_SIZE 64
37 #define DIGITAL_DID_MAX 14
39 #define DIGITAL_PAYLOAD_SIZE_MAX 254
40 #define DIGITAL_PAYLOAD_BITS_TO_PP(s) (((s) & 0x3) << 4)
41 #define DIGITAL_PAYLOAD_PP_TO_BITS(s) (((s) >> 4) & 0x3)
42 #define DIGITAL_PAYLOAD_BITS_TO_FSL(s) ((s) & 0x3)
43 #define DIGITAL_PAYLOAD_FSL_TO_BITS(s) ((s) & 0x3)
45 #define DIGITAL_GB_BIT 0x02
47 #define DIGITAL_NFC_DEP_REQ_RES_HEADROOM 2 /* SoD: [SB (NFC-A)] + LEN */
48 #define DIGITAL_NFC_DEP_REQ_RES_TAILROOM 2 /* EoD: 2-byte CRC */
50 #define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0)
52 #define DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT 0x10
53 #define DIGITAL_NFC_DEP_PFB_MI_BIT 0x10
54 #define DIGITAL_NFC_DEP_PFB_NACK_BIT 0x10
55 #define DIGITAL_NFC_DEP_PFB_DID_BIT 0x04
57 #define DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb) \
58 ((pfb) & DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT)
59 #define DIGITAL_NFC_DEP_MI_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_MI_BIT)
60 #define DIGITAL_NFC_DEP_NACK_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_NACK_BIT)
61 #define DIGITAL_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08)
62 #define DIGITAL_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_DID_BIT)
63 #define DIGITAL_NFC_DEP_PFB_PNI(pfb) ((pfb) & 0x03)
65 #define DIGITAL_NFC_DEP_PFB_I_PDU 0x00
66 #define DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU 0x40
67 #define DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU 0x80
69 struct digital_atr_req {
80 struct digital_atr_res {
92 struct digital_psl_req {
100 struct digital_psl_res {
106 struct digital_dep_req_res {
112 static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
113 struct sk_buff *resp);
114 static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
115 struct sk_buff *resp);
117 static const u8 digital_payload_bits_map[4] = {
124 static u8 digital_payload_bits_to_size(u8 payload_bits)
126 if (payload_bits >= ARRAY_SIZE(digital_payload_bits_map))
129 return digital_payload_bits_map[payload_bits];
132 static u8 digital_payload_size_to_bits(u8 payload_size)
136 for (i = 0; i < ARRAY_SIZE(digital_payload_bits_map); i++)
137 if (digital_payload_bits_map[i] == payload_size)
143 static void digital_skb_push_dep_sod(struct nfc_digital_dev *ddev,
146 skb_push(skb, sizeof(u8));
148 skb->data[0] = skb->len;
150 if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
151 *skb_push(skb, sizeof(u8)) = DIGITAL_NFC_DEP_NFCA_SOD_SB;
154 static int digital_skb_pull_dep_sod(struct nfc_digital_dev *ddev,
162 if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
163 skb_pull(skb, sizeof(u8));
166 if (size != skb->len)
169 skb_pull(skb, sizeof(u8));
174 static struct sk_buff *
175 digital_send_dep_data_prep(struct nfc_digital_dev *ddev, struct sk_buff *skb,
176 struct digital_dep_req_res *dep_req_res,
177 struct digital_data_exch *data_exch)
179 struct sk_buff *new_skb;
181 if (skb->len > ddev->remote_payload_max) {
182 dep_req_res->pfb |= DIGITAL_NFC_DEP_PFB_MI_BIT;
184 new_skb = digital_skb_alloc(ddev, ddev->remote_payload_max);
186 kfree_skb(ddev->chaining_skb);
187 ddev->chaining_skb = NULL;
189 return ERR_PTR(-ENOMEM);
192 skb_reserve(new_skb, ddev->tx_headroom + NFC_HEADER_SIZE +
193 DIGITAL_NFC_DEP_REQ_RES_HEADROOM);
194 memcpy(skb_put(new_skb, ddev->remote_payload_max), skb->data,
195 ddev->remote_payload_max);
196 skb_pull(skb, ddev->remote_payload_max);
198 ddev->chaining_skb = skb;
199 ddev->data_exch = data_exch;
201 ddev->chaining_skb = NULL;
208 static struct sk_buff *
209 digital_recv_dep_data_gather(struct nfc_digital_dev *ddev, u8 pfb,
210 struct sk_buff *resp,
211 int (*send_ack)(struct nfc_digital_dev *ddev,
212 struct digital_data_exch
214 struct digital_data_exch *data_exch)
216 struct sk_buff *new_skb;
219 if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb) && (!ddev->chaining_skb)) {
221 nfc_alloc_recv_skb(8 * ddev->local_payload_max,
223 if (!ddev->chaining_skb) {
229 if (ddev->chaining_skb) {
230 if (resp->len > skb_tailroom(ddev->chaining_skb)) {
231 new_skb = skb_copy_expand(ddev->chaining_skb,
234 8 * ddev->local_payload_max,
241 kfree_skb(ddev->chaining_skb);
242 ddev->chaining_skb = new_skb;
245 memcpy(skb_put(ddev->chaining_skb, resp->len), resp->data,
251 if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb)) {
252 rc = send_ack(ddev, data_exch);
259 resp = ddev->chaining_skb;
260 ddev->chaining_skb = NULL;
268 kfree_skb(ddev->chaining_skb);
269 ddev->chaining_skb = NULL;
274 static void digital_in_recv_psl_res(struct nfc_digital_dev *ddev, void *arg,
275 struct sk_buff *resp)
277 struct nfc_target *target = arg;
278 struct digital_psl_res *psl_res;
287 rc = ddev->skb_check_crc(resp);
289 PROTOCOL_ERR("14.4.1.6");
293 rc = digital_skb_pull_dep_sod(ddev, resp);
295 PROTOCOL_ERR("14.4.1.2");
299 psl_res = (struct digital_psl_res *)resp->data;
301 if ((resp->len != sizeof(*psl_res)) ||
302 (psl_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN) ||
303 (psl_res->cmd != DIGITAL_CMD_PSL_RES)) {
308 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
309 NFC_DIGITAL_RF_TECH_424F);
313 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
314 NFC_DIGITAL_FRAMING_NFCF_NFC_DEP);
318 if (!DIGITAL_DRV_CAPS_IN_CRC(ddev) &&
319 (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)) {
320 ddev->skb_add_crc = digital_skb_add_crc_f;
321 ddev->skb_check_crc = digital_skb_check_crc_f;
324 ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_424F;
326 nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
329 ddev->curr_nfc_dep_pni = 0;
335 ddev->curr_protocol = 0;
338 static int digital_in_send_psl_req(struct nfc_digital_dev *ddev,
339 struct nfc_target *target)
342 struct digital_psl_req *psl_req;
344 u8 payload_size, payload_bits;
346 skb = digital_skb_alloc(ddev, sizeof(*psl_req));
350 skb_put(skb, sizeof(*psl_req));
352 psl_req = (struct digital_psl_req *)skb->data;
354 psl_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
355 psl_req->cmd = DIGITAL_CMD_PSL_REQ;
357 psl_req->brs = (0x2 << 3) | 0x2; /* 424F both directions */
359 payload_size = min(ddev->local_payload_max, ddev->remote_payload_max);
360 payload_bits = digital_payload_size_to_bits(payload_size);
361 psl_req->fsl = DIGITAL_PAYLOAD_BITS_TO_FSL(payload_bits);
363 ddev->local_payload_max = payload_size;
364 ddev->remote_payload_max = payload_size;
366 digital_skb_push_dep_sod(ddev, skb);
368 ddev->skb_add_crc(skb);
370 rc = digital_in_send_cmd(ddev, skb, 500, digital_in_recv_psl_res,
378 static void digital_in_recv_atr_res(struct nfc_digital_dev *ddev, void *arg,
379 struct sk_buff *resp)
381 struct nfc_target *target = arg;
382 struct digital_atr_res *atr_res;
383 u8 gb_len, payload_bits;
392 rc = ddev->skb_check_crc(resp);
394 PROTOCOL_ERR("14.4.1.6");
398 rc = digital_skb_pull_dep_sod(ddev, resp);
400 PROTOCOL_ERR("14.4.1.2");
404 if (resp->len < sizeof(struct digital_atr_res)) {
409 gb_len = resp->len - sizeof(struct digital_atr_res);
411 atr_res = (struct digital_atr_res *)resp->data;
413 payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_res->pp);
414 ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
416 if (!ddev->remote_payload_max) {
421 rc = nfc_set_remote_general_bytes(ddev->nfc_dev, atr_res->gb, gb_len);
425 if ((ddev->protocols & NFC_PROTO_FELICA_MASK) &&
426 (ddev->curr_rf_tech != NFC_DIGITAL_RF_TECH_424F)) {
427 rc = digital_in_send_psl_req(ddev, target);
432 rc = nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
435 ddev->curr_nfc_dep_pni = 0;
441 ddev->curr_protocol = 0;
444 int digital_in_send_atr_req(struct nfc_digital_dev *ddev,
445 struct nfc_target *target, __u8 comm_mode, __u8 *gb,
449 struct digital_atr_req *atr_req;
454 size = DIGITAL_ATR_REQ_MIN_SIZE + gb_len;
456 if (size > DIGITAL_ATR_REQ_MAX_SIZE) {
457 PROTOCOL_ERR("14.6.1.1");
461 skb = digital_skb_alloc(ddev, size);
465 skb_put(skb, sizeof(struct digital_atr_req));
467 atr_req = (struct digital_atr_req *)skb->data;
468 memset(atr_req, 0, sizeof(struct digital_atr_req));
470 atr_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
471 atr_req->cmd = DIGITAL_CMD_ATR_REQ;
472 if (target->nfcid2_len)
473 memcpy(atr_req->nfcid3, target->nfcid2, NFC_NFCID2_MAXSIZE);
475 get_random_bytes(atr_req->nfcid3, NFC_NFCID3_MAXSIZE);
481 ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX;
482 payload_bits = digital_payload_size_to_bits(ddev->local_payload_max);
483 atr_req->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits);
486 atr_req->pp |= DIGITAL_GB_BIT;
487 memcpy(skb_put(skb, gb_len), gb, gb_len);
490 digital_skb_push_dep_sod(ddev, skb);
492 ddev->skb_add_crc(skb);
494 rc = digital_in_send_cmd(ddev, skb, 500, digital_in_recv_atr_res,
502 static int digital_in_send_ack(struct nfc_digital_dev *ddev,
503 struct digital_data_exch *data_exch)
505 struct digital_dep_req_res *dep_req;
509 skb = digital_skb_alloc(ddev, 1);
513 skb_push(skb, sizeof(struct digital_dep_req_res));
515 dep_req = (struct digital_dep_req_res *)skb->data;
517 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
518 dep_req->cmd = DIGITAL_CMD_DEP_REQ;
519 dep_req->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
520 ddev->curr_nfc_dep_pni;
522 digital_skb_push_dep_sod(ddev, skb);
524 ddev->skb_add_crc(skb);
526 rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
534 static int digital_in_send_nack(struct nfc_digital_dev *ddev,
535 struct digital_data_exch *data_exch)
537 struct digital_dep_req_res *dep_req;
541 skb = digital_skb_alloc(ddev, 1);
545 skb_push(skb, sizeof(struct digital_dep_req_res));
547 dep_req = (struct digital_dep_req_res *)skb->data;
549 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
550 dep_req->cmd = DIGITAL_CMD_DEP_REQ;
551 dep_req->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
552 DIGITAL_NFC_DEP_PFB_NACK_BIT | ddev->curr_nfc_dep_pni;
554 digital_skb_push_dep_sod(ddev, skb);
556 ddev->skb_add_crc(skb);
558 rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
566 static int digital_in_send_rtox(struct nfc_digital_dev *ddev,
567 struct digital_data_exch *data_exch, u8 rtox)
569 struct digital_dep_req_res *dep_req;
573 skb = digital_skb_alloc(ddev, 1);
577 *skb_put(skb, 1) = rtox;
579 skb_push(skb, sizeof(struct digital_dep_req_res));
581 dep_req = (struct digital_dep_req_res *)skb->data;
583 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
584 dep_req->cmd = DIGITAL_CMD_DEP_REQ;
585 dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU |
586 DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT;
588 digital_skb_push_dep_sod(ddev, skb);
590 ddev->skb_add_crc(skb);
592 rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
600 static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
601 struct sk_buff *resp)
603 struct digital_data_exch *data_exch = arg;
604 struct digital_dep_req_res *dep_res;
613 if ((rc != -ETIMEDOUT) &&
614 (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) {
615 rc = digital_in_send_nack(ddev, data_exch);
625 rc = digital_skb_pull_dep_sod(ddev, resp);
627 PROTOCOL_ERR("14.4.1.2");
631 rc = ddev->skb_check_crc(resp);
633 if ((resp->len >= 4) &&
634 (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) {
635 rc = digital_in_send_nack(ddev, data_exch);
644 PROTOCOL_ERR("14.4.1.6");
648 ddev->nack_count = 0;
650 if (resp->len > ddev->local_payload_max) {
655 size = sizeof(struct digital_dep_req_res);
656 dep_res = (struct digital_dep_req_res *)resp->data;
658 if (resp->len < size || dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN ||
659 dep_res->cmd != DIGITAL_CMD_DEP_RES) {
666 if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
667 PROTOCOL_ERR("14.8.2.1");
672 if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
677 if (size > resp->len) {
682 skb_pull(resp, size);
684 switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
685 case DIGITAL_NFC_DEP_PFB_I_PDU:
686 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
687 PROTOCOL_ERR("14.12.3.3");
692 ddev->curr_nfc_dep_pni =
693 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
695 resp = digital_recv_dep_data_gather(ddev, pfb, resp,
704 /* If resp is NULL then we're still chaining so return and
705 * wait for the next part of the PDU. Else, the PDU is
706 * complete so pass it up.
714 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
715 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
716 PROTOCOL_ERR("14.12.3.3");
721 ddev->curr_nfc_dep_pni =
722 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
724 if (ddev->chaining_skb && !DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) {
725 rc = digital_in_send_dep_req(ddev, NULL,
734 pr_err("Received a ACK/NACK PDU\n");
738 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
739 if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) {
744 rc = digital_in_send_rtox(ddev, data_exch, resp->data[0]);
753 data_exch->cb(data_exch->cb_context, resp, rc);
758 kfree_skb(ddev->chaining_skb);
759 ddev->chaining_skb = NULL;
765 int digital_in_send_dep_req(struct nfc_digital_dev *ddev,
766 struct nfc_target *target, struct sk_buff *skb,
767 struct digital_data_exch *data_exch)
769 struct digital_dep_req_res *dep_req;
770 struct sk_buff *chaining_skb, *tmp_skb;
773 skb_push(skb, sizeof(struct digital_dep_req_res));
775 dep_req = (struct digital_dep_req_res *)skb->data;
777 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
778 dep_req->cmd = DIGITAL_CMD_DEP_REQ;
779 dep_req->pfb = ddev->curr_nfc_dep_pni;
781 ddev->nack_count = 0;
783 chaining_skb = ddev->chaining_skb;
785 tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_req, data_exch);
787 return PTR_ERR(tmp_skb);
789 digital_skb_push_dep_sod(ddev, tmp_skb);
791 ddev->skb_add_crc(tmp_skb);
793 rc = digital_in_send_cmd(ddev, tmp_skb, 1500, digital_in_recv_dep_res,
799 kfree_skb(chaining_skb);
800 ddev->chaining_skb = NULL;
806 static void digital_tg_set_rf_tech(struct nfc_digital_dev *ddev, u8 rf_tech)
808 ddev->curr_rf_tech = rf_tech;
810 ddev->skb_add_crc = digital_skb_add_crc_none;
811 ddev->skb_check_crc = digital_skb_check_crc_none;
813 if (DIGITAL_DRV_CAPS_TG_CRC(ddev))
816 switch (ddev->curr_rf_tech) {
817 case NFC_DIGITAL_RF_TECH_106A:
818 ddev->skb_add_crc = digital_skb_add_crc_a;
819 ddev->skb_check_crc = digital_skb_check_crc_a;
822 case NFC_DIGITAL_RF_TECH_212F:
823 case NFC_DIGITAL_RF_TECH_424F:
824 ddev->skb_add_crc = digital_skb_add_crc_f;
825 ddev->skb_check_crc = digital_skb_check_crc_f;
833 static int digital_tg_send_ack(struct nfc_digital_dev *ddev,
834 struct digital_data_exch *data_exch)
836 struct digital_dep_req_res *dep_res;
840 skb = digital_skb_alloc(ddev, 1);
844 skb_push(skb, sizeof(struct digital_dep_req_res));
846 dep_res = (struct digital_dep_req_res *)skb->data;
848 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
849 dep_res->cmd = DIGITAL_CMD_DEP_RES;
850 dep_res->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
851 ddev->curr_nfc_dep_pni;
854 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
856 memcpy(skb_put(skb, sizeof(ddev->did)), &ddev->did,
860 ddev->curr_nfc_dep_pni =
861 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
863 digital_skb_push_dep_sod(ddev, skb);
865 ddev->skb_add_crc(skb);
867 rc = digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
875 static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
876 struct sk_buff *resp)
879 struct digital_dep_req_res *dep_req;
889 rc = ddev->skb_check_crc(resp);
891 PROTOCOL_ERR("14.4.1.6");
895 rc = digital_skb_pull_dep_sod(ddev, resp);
897 PROTOCOL_ERR("14.4.1.2");
901 if (resp->len > ddev->local_payload_max) {
906 size = sizeof(struct digital_dep_req_res);
907 dep_req = (struct digital_dep_req_res *)resp->data;
909 if (resp->len < size || dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
910 dep_req->cmd != DIGITAL_CMD_DEP_REQ) {
917 if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
918 if (ddev->did && (ddev->did == resp->data[3])) {
924 } else if (ddev->did) {
929 if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
934 if (size > resp->len) {
939 skb_pull(resp, size);
941 switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
942 case DIGITAL_NFC_DEP_PFB_I_PDU:
943 pr_debug("DIGITAL_NFC_DEP_PFB_I_PDU\n");
945 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
946 PROTOCOL_ERR("14.12.3.4");
951 resp = digital_recv_dep_data_gather(ddev, pfb, resp,
952 digital_tg_send_ack, NULL);
959 /* If resp is NULL then we're still chaining so return and
960 * wait for the next part of the PDU. Else, the PDU is
961 * complete so pass it up.
968 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
969 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
970 PROTOCOL_ERR("14.12.3.4");
975 if (ddev->chaining_skb && !DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) {
976 rc = digital_tg_send_dep_res(ddev, ddev->chaining_skb);
983 pr_err("Received a ACK/NACK PDU\n");
986 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
987 pr_err("Received a SUPERVISOR PDU\n");
992 rc = nfc_tm_data_received(ddev->nfc_dev, resp);
995 kfree_skb(ddev->chaining_skb);
996 ddev->chaining_skb = NULL;
1002 int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb)
1004 struct digital_dep_req_res *dep_res;
1005 struct sk_buff *chaining_skb, *tmp_skb;
1008 skb_push(skb, sizeof(struct digital_dep_req_res));
1010 dep_res = (struct digital_dep_req_res *)skb->data;
1012 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1013 dep_res->cmd = DIGITAL_CMD_DEP_RES;
1014 dep_res->pfb = ddev->curr_nfc_dep_pni;
1017 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
1019 memcpy(skb_put(skb, sizeof(ddev->did)), &ddev->did,
1023 ddev->curr_nfc_dep_pni =
1024 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
1026 chaining_skb = ddev->chaining_skb;
1028 tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_res, NULL);
1029 if (IS_ERR(tmp_skb))
1030 return PTR_ERR(tmp_skb);
1032 digital_skb_push_dep_sod(ddev, tmp_skb);
1034 ddev->skb_add_crc(tmp_skb);
1036 rc = digital_tg_send_cmd(ddev, tmp_skb, 1500, digital_tg_recv_dep_req,
1042 kfree_skb(chaining_skb);
1043 ddev->chaining_skb = NULL;
1049 static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev,
1050 void *arg, struct sk_buff *resp)
1052 u8 rf_tech = (unsigned long)arg;
1057 digital_tg_set_rf_tech(ddev, rf_tech);
1059 digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
1061 digital_tg_listen(ddev, 1500, digital_tg_recv_dep_req, NULL);
1063 dev_kfree_skb(resp);
1066 static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did,
1069 struct digital_psl_res *psl_res;
1070 struct sk_buff *skb;
1073 skb = digital_skb_alloc(ddev, sizeof(struct digital_psl_res));
1077 skb_put(skb, sizeof(struct digital_psl_res));
1079 psl_res = (struct digital_psl_res *)skb->data;
1081 psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1082 psl_res->cmd = DIGITAL_CMD_PSL_RES;
1085 digital_skb_push_dep_sod(ddev, skb);
1087 ddev->skb_add_crc(skb);
1089 ddev->curr_nfc_dep_pni = 0;
1091 rc = digital_tg_send_cmd(ddev, skb, 0, digital_tg_send_psl_res_complete,
1092 (void *)(unsigned long)rf_tech);
1099 static void digital_tg_recv_psl_req(struct nfc_digital_dev *ddev, void *arg,
1100 struct sk_buff *resp)
1103 struct digital_psl_req *psl_req;
1105 u8 dsi, payload_size, payload_bits;
1113 rc = ddev->skb_check_crc(resp);
1115 PROTOCOL_ERR("14.4.1.6");
1119 rc = digital_skb_pull_dep_sod(ddev, resp);
1121 PROTOCOL_ERR("14.4.1.2");
1125 psl_req = (struct digital_psl_req *)resp->data;
1127 if (resp->len != sizeof(struct digital_psl_req) ||
1128 psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1129 psl_req->cmd != DIGITAL_CMD_PSL_REQ) {
1134 dsi = (psl_req->brs >> 3) & 0x07;
1137 rf_tech = NFC_DIGITAL_RF_TECH_106A;
1140 rf_tech = NFC_DIGITAL_RF_TECH_212F;
1143 rf_tech = NFC_DIGITAL_RF_TECH_424F;
1146 pr_err("Unsupported dsi value %d\n", dsi);
1150 payload_bits = DIGITAL_PAYLOAD_FSL_TO_BITS(psl_req->fsl);
1151 payload_size = digital_payload_bits_to_size(payload_bits);
1153 if (!payload_size || (payload_size > min(ddev->local_payload_max,
1154 ddev->remote_payload_max))) {
1159 ddev->local_payload_max = payload_size;
1160 ddev->remote_payload_max = payload_size;
1162 rc = digital_tg_send_psl_res(ddev, psl_req->did, rf_tech);
1168 static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev,
1169 void *arg, struct sk_buff *resp)
1174 digital_poll_next_tech(ddev);
1179 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB)
1182 if (resp->data[offset] == DIGITAL_CMD_PSL_REQ)
1183 digital_tg_recv_psl_req(ddev, arg, resp);
1185 digital_tg_recv_dep_req(ddev, arg, resp);
1188 static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev,
1189 struct digital_atr_req *atr_req)
1191 struct digital_atr_res *atr_res;
1192 struct sk_buff *skb;
1193 u8 *gb, payload_bits;
1197 gb = nfc_get_local_general_bytes(ddev->nfc_dev, &gb_len);
1201 skb = digital_skb_alloc(ddev, sizeof(struct digital_atr_res) + gb_len);
1205 skb_put(skb, sizeof(struct digital_atr_res));
1206 atr_res = (struct digital_atr_res *)skb->data;
1208 memset(atr_res, 0, sizeof(struct digital_atr_res));
1210 atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1211 atr_res->cmd = DIGITAL_CMD_ATR_RES;
1212 memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3));
1215 ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX;
1216 payload_bits = digital_payload_size_to_bits(ddev->local_payload_max);
1217 atr_res->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits);
1220 skb_put(skb, gb_len);
1222 atr_res->pp |= DIGITAL_GB_BIT;
1223 memcpy(atr_res->gb, gb, gb_len);
1226 digital_skb_push_dep_sod(ddev, skb);
1228 ddev->skb_add_crc(skb);
1230 ddev->curr_nfc_dep_pni = 0;
1232 rc = digital_tg_send_cmd(ddev, skb, 999,
1233 digital_tg_send_atr_res_complete, NULL);
1240 void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg,
1241 struct sk_buff *resp)
1244 struct digital_atr_req *atr_req;
1245 size_t gb_len, min_size;
1246 u8 poll_tech_count, payload_bits;
1259 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) {
1260 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2;
1261 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_106A);
1263 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1;
1264 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_212F);
1267 if (resp->len < min_size) {
1272 ddev->curr_protocol = NFC_PROTO_NFC_DEP_MASK;
1274 rc = ddev->skb_check_crc(resp);
1276 PROTOCOL_ERR("14.4.1.6");
1280 rc = digital_skb_pull_dep_sod(ddev, resp);
1282 PROTOCOL_ERR("14.4.1.2");
1286 atr_req = (struct digital_atr_req *)resp->data;
1288 if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1289 atr_req->cmd != DIGITAL_CMD_ATR_REQ ||
1290 atr_req->did > DIGITAL_DID_MAX) {
1295 payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_req->pp);
1296 ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
1298 if (!ddev->remote_payload_max) {
1303 ddev->did = atr_req->did;
1305 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1306 NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED);
1310 rc = digital_tg_send_atr_res(ddev, atr_req);
1314 gb_len = resp->len - sizeof(struct digital_atr_req);
1316 poll_tech_count = ddev->poll_tech_count;
1317 ddev->poll_tech_count = 0;
1319 rc = nfc_tm_activated(ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
1320 NFC_COMM_PASSIVE, atr_req->gb, gb_len);
1322 ddev->poll_tech_count = poll_tech_count;
1329 digital_poll_next_tech(ddev);
1331 dev_kfree_skb(resp);