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
21 #define DIGITAL_NFC_DEP_N_RETRY_ATN 2
23 #define DIGITAL_NFC_DEP_FRAME_DIR_OUT 0xD4
24 #define DIGITAL_NFC_DEP_FRAME_DIR_IN 0xD5
26 #define DIGITAL_NFC_DEP_NFCA_SOD_SB 0xF0
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
35 #define DIGITAL_ATR_REQ_MIN_SIZE 16
36 #define DIGITAL_ATR_REQ_MAX_SIZE 64
38 #define DIGITAL_DID_MAX 14
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)
46 #define DIGITAL_GB_BIT 0x02
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 */
51 #define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0)
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
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)
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
70 struct digital_atr_req {
81 struct digital_atr_res {
93 struct digital_psl_req {
101 struct digital_psl_res {
107 struct digital_dep_req_res {
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);
118 static const u8 digital_payload_bits_map[4] = {
125 static u8 digital_payload_bits_to_size(u8 payload_bits)
127 if (payload_bits >= ARRAY_SIZE(digital_payload_bits_map))
130 return digital_payload_bits_map[payload_bits];
133 static u8 digital_payload_size_to_bits(u8 payload_size)
137 for (i = 0; i < ARRAY_SIZE(digital_payload_bits_map); i++)
138 if (digital_payload_bits_map[i] == payload_size)
144 static void digital_skb_push_dep_sod(struct nfc_digital_dev *ddev,
147 skb_push(skb, sizeof(u8));
149 skb->data[0] = skb->len;
151 if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
152 *skb_push(skb, sizeof(u8)) = DIGITAL_NFC_DEP_NFCA_SOD_SB;
155 static int digital_skb_pull_dep_sod(struct nfc_digital_dev *ddev,
163 if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
164 skb_pull(skb, sizeof(u8));
167 if (size != skb->len)
170 skb_pull(skb, sizeof(u8));
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)
180 struct sk_buff *new_skb;
182 if (skb->len > ddev->remote_payload_max) {
183 dep_req_res->pfb |= DIGITAL_NFC_DEP_PFB_MI_BIT;
185 new_skb = digital_skb_alloc(ddev, ddev->remote_payload_max);
187 kfree_skb(ddev->chaining_skb);
188 ddev->chaining_skb = NULL;
190 return ERR_PTR(-ENOMEM);
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);
197 ddev->chaining_skb = skb;
198 ddev->data_exch = data_exch;
200 ddev->chaining_skb = NULL;
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
213 struct digital_data_exch *data_exch)
215 struct sk_buff *new_skb;
218 if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb) && (!ddev->chaining_skb)) {
220 nfc_alloc_recv_skb(8 * ddev->local_payload_max,
222 if (!ddev->chaining_skb) {
228 if (ddev->chaining_skb) {
229 if (resp->len > skb_tailroom(ddev->chaining_skb)) {
230 new_skb = skb_copy_expand(ddev->chaining_skb,
233 8 * ddev->local_payload_max,
240 kfree_skb(ddev->chaining_skb);
241 ddev->chaining_skb = new_skb;
244 memcpy(skb_put(ddev->chaining_skb, resp->len), resp->data,
250 if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb)) {
251 rc = send_ack(ddev, data_exch);
258 resp = ddev->chaining_skb;
259 ddev->chaining_skb = NULL;
267 kfree_skb(ddev->chaining_skb);
268 ddev->chaining_skb = NULL;
273 static void digital_in_recv_psl_res(struct nfc_digital_dev *ddev, void *arg,
274 struct sk_buff *resp)
276 struct nfc_target *target = arg;
277 struct digital_psl_res *psl_res;
286 rc = ddev->skb_check_crc(resp);
288 PROTOCOL_ERR("14.4.1.6");
292 rc = digital_skb_pull_dep_sod(ddev, resp);
294 PROTOCOL_ERR("14.4.1.2");
298 psl_res = (struct digital_psl_res *)resp->data;
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)) {
307 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
308 NFC_DIGITAL_RF_TECH_424F);
312 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
313 NFC_DIGITAL_FRAMING_NFCF_NFC_DEP);
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;
323 ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_424F;
325 nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
328 ddev->curr_nfc_dep_pni = 0;
334 ddev->curr_protocol = 0;
337 static int digital_in_send_psl_req(struct nfc_digital_dev *ddev,
338 struct nfc_target *target)
341 struct digital_psl_req *psl_req;
343 u8 payload_size, payload_bits;
345 skb = digital_skb_alloc(ddev, sizeof(*psl_req));
349 skb_put(skb, sizeof(*psl_req));
351 psl_req = (struct digital_psl_req *)skb->data;
353 psl_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
354 psl_req->cmd = DIGITAL_CMD_PSL_REQ;
356 psl_req->brs = (0x2 << 3) | 0x2; /* 424F both directions */
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);
362 ddev->local_payload_max = payload_size;
363 ddev->remote_payload_max = payload_size;
365 digital_skb_push_dep_sod(ddev, skb);
367 ddev->skb_add_crc(skb);
369 rc = digital_in_send_cmd(ddev, skb, 500, digital_in_recv_psl_res,
377 static void digital_in_recv_atr_res(struct nfc_digital_dev *ddev, void *arg,
378 struct sk_buff *resp)
380 struct nfc_target *target = arg;
381 struct digital_atr_res *atr_res;
382 u8 gb_len, payload_bits;
391 rc = ddev->skb_check_crc(resp);
393 PROTOCOL_ERR("14.4.1.6");
397 rc = digital_skb_pull_dep_sod(ddev, resp);
399 PROTOCOL_ERR("14.4.1.2");
403 if (resp->len < sizeof(struct digital_atr_res)) {
408 gb_len = resp->len - sizeof(struct digital_atr_res);
410 atr_res = (struct digital_atr_res *)resp->data;
412 payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_res->pp);
413 ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
415 if (!ddev->remote_payload_max) {
420 rc = nfc_set_remote_general_bytes(ddev->nfc_dev, atr_res->gb, gb_len);
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);
431 rc = nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
434 ddev->curr_nfc_dep_pni = 0;
440 ddev->curr_protocol = 0;
443 int digital_in_send_atr_req(struct nfc_digital_dev *ddev,
444 struct nfc_target *target, __u8 comm_mode, __u8 *gb,
448 struct digital_atr_req *atr_req;
453 size = DIGITAL_ATR_REQ_MIN_SIZE + gb_len;
455 if (size > DIGITAL_ATR_REQ_MAX_SIZE) {
456 PROTOCOL_ERR("14.6.1.1");
460 skb = digital_skb_alloc(ddev, size);
464 skb_put(skb, sizeof(struct digital_atr_req));
466 atr_req = (struct digital_atr_req *)skb->data;
467 memset(atr_req, 0, sizeof(struct digital_atr_req));
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);
474 get_random_bytes(atr_req->nfcid3, NFC_NFCID3_MAXSIZE);
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);
485 atr_req->pp |= DIGITAL_GB_BIT;
486 memcpy(skb_put(skb, gb_len), gb, gb_len);
489 digital_skb_push_dep_sod(ddev, skb);
491 ddev->skb_add_crc(skb);
493 rc = digital_in_send_cmd(ddev, skb, 500, digital_in_recv_atr_res,
501 static int digital_in_send_ack(struct nfc_digital_dev *ddev,
502 struct digital_data_exch *data_exch)
504 struct digital_dep_req_res *dep_req;
508 skb = digital_skb_alloc(ddev, 1);
512 skb_push(skb, sizeof(struct digital_dep_req_res));
514 dep_req = (struct digital_dep_req_res *)skb->data;
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;
521 digital_skb_push_dep_sod(ddev, skb);
523 ddev->skb_add_crc(skb);
525 ddev->saved_skb = pskb_copy(skb, GFP_KERNEL);
527 rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
531 kfree_skb(ddev->saved_skb);
532 ddev->saved_skb = NULL;
538 static int digital_in_send_nack(struct nfc_digital_dev *ddev,
539 struct digital_data_exch *data_exch)
541 struct digital_dep_req_res *dep_req;
545 skb = digital_skb_alloc(ddev, 1);
549 skb_push(skb, sizeof(struct digital_dep_req_res));
551 dep_req = (struct digital_dep_req_res *)skb->data;
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;
558 digital_skb_push_dep_sod(ddev, skb);
560 ddev->skb_add_crc(skb);
562 rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
570 static int digital_in_send_atn(struct nfc_digital_dev *ddev,
571 struct digital_data_exch *data_exch)
573 struct digital_dep_req_res *dep_req;
577 skb = digital_skb_alloc(ddev, 1);
581 skb_push(skb, sizeof(struct digital_dep_req_res));
583 dep_req = (struct digital_dep_req_res *)skb->data;
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;
589 digital_skb_push_dep_sod(ddev, skb);
591 ddev->skb_add_crc(skb);
593 rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
601 static int digital_in_send_rtox(struct nfc_digital_dev *ddev,
602 struct digital_data_exch *data_exch, u8 rtox)
604 struct digital_dep_req_res *dep_req;
608 skb = digital_skb_alloc(ddev, 1);
612 *skb_put(skb, 1) = rtox;
614 skb_push(skb, sizeof(struct digital_dep_req_res));
616 dep_req = (struct digital_dep_req_res *)skb->data;
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;
623 digital_skb_push_dep_sod(ddev, skb);
625 ddev->skb_add_crc(skb);
627 rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
635 static int digital_in_send_saved_skb(struct nfc_digital_dev *ddev,
636 struct digital_data_exch *data_exch)
640 if (!ddev->saved_skb)
643 skb_get(ddev->saved_skb);
645 rc = digital_in_send_cmd(ddev, ddev->saved_skb, 1500,
646 digital_in_recv_dep_res, data_exch);
648 kfree_skb(ddev->saved_skb);
653 static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
654 struct sk_buff *resp)
656 struct digital_data_exch *data_exch = arg;
657 struct digital_dep_req_res *dep_res;
666 if ((rc == -EIO || (rc == -ETIMEDOUT && ddev->nack_count)) &&
667 (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) {
670 rc = digital_in_send_nack(ddev, data_exch);
675 } else if ((rc == -ETIMEDOUT) &&
676 (ddev->atn_count++ < DIGITAL_NFC_DEP_N_RETRY_ATN)) {
677 ddev->nack_count = 0;
679 rc = digital_in_send_atn(ddev, data_exch);
689 rc = digital_skb_pull_dep_sod(ddev, resp);
691 PROTOCOL_ERR("14.4.1.2");
695 rc = ddev->skb_check_crc(resp);
697 if ((resp->len >= 4) &&
698 (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) {
701 rc = digital_in_send_nack(ddev, data_exch);
710 PROTOCOL_ERR("14.4.1.6");
715 ddev->nack_count = 0;
717 if (resp->len > ddev->local_payload_max) {
722 size = sizeof(struct digital_dep_req_res);
723 dep_res = (struct digital_dep_req_res *)resp->data;
725 if (resp->len < size || dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN ||
726 dep_res->cmd != DIGITAL_CMD_DEP_RES) {
733 if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
734 PROTOCOL_ERR("14.8.2.1");
739 if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
744 if (size > resp->len) {
749 skb_pull(resp, size);
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");
759 ddev->curr_nfc_dep_pni =
760 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
762 kfree_skb(ddev->saved_skb);
763 ddev->saved_skb = NULL;
765 resp = digital_recv_dep_data_gather(ddev, pfb, resp,
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.
784 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
785 if (DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) {
786 PROTOCOL_ERR("14.12.4.5");
791 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
792 PROTOCOL_ERR("14.12.3.3");
797 ddev->curr_nfc_dep_pni =
798 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
800 if (!ddev->chaining_skb) {
801 PROTOCOL_ERR("14.12.4.3");
806 /* The initiator has received a valid ACK. Free the last sent
807 * PDU and keep on sending chained skb.
809 kfree_skb(ddev->saved_skb);
810 ddev->saved_skb = NULL;
812 rc = digital_in_send_dep_req(ddev, NULL,
820 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
821 if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) { /* ATN */
822 rc = digital_in_send_saved_skb(ddev, data_exch);
829 rc = digital_in_send_rtox(ddev, data_exch, resp->data[0]);
838 data_exch->cb(data_exch->cb_context, resp, rc);
843 kfree_skb(ddev->chaining_skb);
844 ddev->chaining_skb = NULL;
846 kfree_skb(ddev->saved_skb);
847 ddev->saved_skb = NULL;
858 int digital_in_send_dep_req(struct nfc_digital_dev *ddev,
859 struct nfc_target *target, struct sk_buff *skb,
860 struct digital_data_exch *data_exch)
862 struct digital_dep_req_res *dep_req;
863 struct sk_buff *chaining_skb, *tmp_skb;
866 skb_push(skb, sizeof(struct digital_dep_req_res));
868 dep_req = (struct digital_dep_req_res *)skb->data;
870 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
871 dep_req->cmd = DIGITAL_CMD_DEP_REQ;
872 dep_req->pfb = ddev->curr_nfc_dep_pni;
875 ddev->nack_count = 0;
877 chaining_skb = ddev->chaining_skb;
879 tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_req, data_exch);
881 return PTR_ERR(tmp_skb);
883 digital_skb_push_dep_sod(ddev, tmp_skb);
885 ddev->skb_add_crc(tmp_skb);
887 ddev->saved_skb = pskb_copy(tmp_skb, GFP_KERNEL);
889 rc = digital_in_send_cmd(ddev, tmp_skb, 1500, digital_in_recv_dep_res,
895 kfree_skb(chaining_skb);
896 ddev->chaining_skb = NULL;
898 kfree_skb(ddev->saved_skb);
899 ddev->saved_skb = NULL;
905 static void digital_tg_set_rf_tech(struct nfc_digital_dev *ddev, u8 rf_tech)
907 ddev->curr_rf_tech = rf_tech;
909 ddev->skb_add_crc = digital_skb_add_crc_none;
910 ddev->skb_check_crc = digital_skb_check_crc_none;
912 if (DIGITAL_DRV_CAPS_TG_CRC(ddev))
915 switch (ddev->curr_rf_tech) {
916 case NFC_DIGITAL_RF_TECH_106A:
917 ddev->skb_add_crc = digital_skb_add_crc_a;
918 ddev->skb_check_crc = digital_skb_check_crc_a;
921 case NFC_DIGITAL_RF_TECH_212F:
922 case NFC_DIGITAL_RF_TECH_424F:
923 ddev->skb_add_crc = digital_skb_add_crc_f;
924 ddev->skb_check_crc = digital_skb_check_crc_f;
932 static int digital_tg_send_ack(struct nfc_digital_dev *ddev,
933 struct digital_data_exch *data_exch)
935 struct digital_dep_req_res *dep_res;
939 skb = digital_skb_alloc(ddev, 1);
943 skb_push(skb, sizeof(struct digital_dep_req_res));
945 dep_res = (struct digital_dep_req_res *)skb->data;
947 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
948 dep_res->cmd = DIGITAL_CMD_DEP_RES;
949 dep_res->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
950 ddev->curr_nfc_dep_pni;
953 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
955 memcpy(skb_put(skb, sizeof(ddev->did)), &ddev->did,
959 ddev->curr_nfc_dep_pni =
960 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
962 digital_skb_push_dep_sod(ddev, skb);
964 ddev->skb_add_crc(skb);
966 ddev->saved_skb = pskb_copy(skb, GFP_KERNEL);
968 rc = digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
972 kfree_skb(ddev->saved_skb);
973 ddev->saved_skb = NULL;
979 static int digital_tg_send_atn(struct nfc_digital_dev *ddev)
981 struct digital_dep_req_res *dep_res;
985 skb = digital_skb_alloc(ddev, 1);
989 skb_push(skb, sizeof(struct digital_dep_req_res));
991 dep_res = (struct digital_dep_req_res *)skb->data;
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_SUPERVISOR_PDU;
998 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
1000 memcpy(skb_put(skb, sizeof(ddev->did)), &ddev->did,
1004 digital_skb_push_dep_sod(ddev, skb);
1006 ddev->skb_add_crc(skb);
1008 rc = digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
1016 static int digital_tg_send_saved_skb(struct nfc_digital_dev *ddev)
1020 if (!ddev->saved_skb)
1023 skb_get(ddev->saved_skb);
1025 rc = digital_tg_send_cmd(ddev, ddev->saved_skb, 1500,
1026 digital_tg_recv_dep_req, NULL);
1028 kfree_skb(ddev->saved_skb);
1033 static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
1034 struct sk_buff *resp)
1037 struct digital_dep_req_res *dep_req;
1047 rc = ddev->skb_check_crc(resp);
1049 PROTOCOL_ERR("14.4.1.6");
1053 rc = digital_skb_pull_dep_sod(ddev, resp);
1055 PROTOCOL_ERR("14.4.1.2");
1059 if (resp->len > ddev->local_payload_max) {
1064 size = sizeof(struct digital_dep_req_res);
1065 dep_req = (struct digital_dep_req_res *)resp->data;
1067 if (resp->len < size || dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1068 dep_req->cmd != DIGITAL_CMD_DEP_REQ) {
1075 if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
1076 if (ddev->did && (ddev->did == resp->data[3])) {
1082 } else if (ddev->did) {
1087 if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
1092 if (size > resp->len) {
1097 skb_pull(resp, size);
1099 switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
1100 case DIGITAL_NFC_DEP_PFB_I_PDU:
1101 pr_debug("DIGITAL_NFC_DEP_PFB_I_PDU\n");
1103 if (ddev->atn_count) {
1104 /* The target has received (and replied to) at least one
1107 ddev->atn_count = 0;
1109 /* pni of resp PDU equal to the target current pni - 1
1110 * means resp is the previous DEP_REQ PDU received from
1111 * the initiator so the target replies with saved_skb
1112 * which is the previous DEP_RES saved in
1113 * digital_tg_send_dep_res().
1115 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) ==
1116 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni - 1)) {
1117 rc = digital_tg_send_saved_skb(ddev);
1124 /* atn_count > 0 and PDU pni != curr_nfc_dep_pni - 1
1125 * means the target probably did not received the last
1126 * DEP_REQ PDU sent by the initiator. The target
1127 * fallbacks to normal processing then.
1131 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
1132 PROTOCOL_ERR("14.12.3.4");
1137 kfree_skb(ddev->saved_skb);
1138 ddev->saved_skb = NULL;
1140 resp = digital_recv_dep_data_gather(ddev, pfb, resp,
1141 digital_tg_send_ack, NULL);
1148 /* If resp is NULL then we're still chaining so return and
1149 * wait for the next part of the PDU. Else, the PDU is
1150 * complete so pass it up.
1157 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
1158 if (DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) { /* NACK */
1159 if (DIGITAL_NFC_DEP_PFB_PNI(pfb + 1) !=
1160 ddev->curr_nfc_dep_pni) {
1165 ddev->atn_count = 0;
1167 rc = digital_tg_send_saved_skb(ddev);
1175 if (ddev->atn_count) {
1176 /* The target has previously recevied one or more ATN
1179 ddev->atn_count = 0;
1181 /* If the ACK PNI is equal to the target PNI - 1 means
1182 * that the initiator did not receive the previous PDU
1183 * sent by the target so re-send it.
1185 if (DIGITAL_NFC_DEP_PFB_PNI(pfb + 1) ==
1186 ddev->curr_nfc_dep_pni) {
1187 rc = digital_tg_send_saved_skb(ddev);
1194 /* Otherwise, the target did not receive the previous
1195 * ACK PDU from the initiator. Fallback to normal
1196 * processing of chained PDU then.
1200 /* Keep on sending chained PDU */
1201 if (!ddev->chaining_skb ||
1202 DIGITAL_NFC_DEP_PFB_PNI(pfb) !=
1203 ddev->curr_nfc_dep_pni) {
1208 kfree_skb(ddev->saved_skb);
1209 ddev->saved_skb = NULL;
1211 rc = digital_tg_send_dep_res(ddev, ddev->chaining_skb);
1216 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
1217 if (DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) {
1222 rc = digital_tg_send_atn(ddev);
1232 rc = nfc_tm_data_received(ddev->nfc_dev, resp);
1235 kfree_skb(ddev->chaining_skb);
1236 ddev->chaining_skb = NULL;
1238 ddev->atn_count = 0;
1240 kfree_skb(ddev->saved_skb);
1241 ddev->saved_skb = NULL;
1249 dev_kfree_skb(resp);
1252 int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb)
1254 struct digital_dep_req_res *dep_res;
1255 struct sk_buff *chaining_skb, *tmp_skb;
1258 skb_push(skb, sizeof(struct digital_dep_req_res));
1260 dep_res = (struct digital_dep_req_res *)skb->data;
1262 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1263 dep_res->cmd = DIGITAL_CMD_DEP_RES;
1264 dep_res->pfb = ddev->curr_nfc_dep_pni;
1267 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
1269 memcpy(skb_put(skb, sizeof(ddev->did)), &ddev->did,
1273 ddev->curr_nfc_dep_pni =
1274 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
1276 chaining_skb = ddev->chaining_skb;
1278 tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_res, NULL);
1279 if (IS_ERR(tmp_skb))
1280 return PTR_ERR(tmp_skb);
1282 digital_skb_push_dep_sod(ddev, tmp_skb);
1284 ddev->skb_add_crc(tmp_skb);
1286 ddev->saved_skb = pskb_copy(tmp_skb, GFP_KERNEL);
1288 rc = digital_tg_send_cmd(ddev, tmp_skb, 1500, digital_tg_recv_dep_req,
1294 kfree_skb(chaining_skb);
1295 ddev->chaining_skb = NULL;
1297 kfree_skb(ddev->saved_skb);
1298 ddev->saved_skb = NULL;
1304 static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev,
1305 void *arg, struct sk_buff *resp)
1307 u8 rf_tech = (unsigned long)arg;
1312 digital_tg_set_rf_tech(ddev, rf_tech);
1314 digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
1316 digital_tg_listen(ddev, 1500, digital_tg_recv_dep_req, NULL);
1318 dev_kfree_skb(resp);
1321 static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did,
1324 struct digital_psl_res *psl_res;
1325 struct sk_buff *skb;
1328 skb = digital_skb_alloc(ddev, sizeof(struct digital_psl_res));
1332 skb_put(skb, sizeof(struct digital_psl_res));
1334 psl_res = (struct digital_psl_res *)skb->data;
1336 psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1337 psl_res->cmd = DIGITAL_CMD_PSL_RES;
1340 digital_skb_push_dep_sod(ddev, skb);
1342 ddev->skb_add_crc(skb);
1344 ddev->curr_nfc_dep_pni = 0;
1346 rc = digital_tg_send_cmd(ddev, skb, 0, digital_tg_send_psl_res_complete,
1347 (void *)(unsigned long)rf_tech);
1354 static void digital_tg_recv_psl_req(struct nfc_digital_dev *ddev, void *arg,
1355 struct sk_buff *resp)
1358 struct digital_psl_req *psl_req;
1360 u8 dsi, payload_size, payload_bits;
1368 rc = ddev->skb_check_crc(resp);
1370 PROTOCOL_ERR("14.4.1.6");
1374 rc = digital_skb_pull_dep_sod(ddev, resp);
1376 PROTOCOL_ERR("14.4.1.2");
1380 psl_req = (struct digital_psl_req *)resp->data;
1382 if (resp->len != sizeof(struct digital_psl_req) ||
1383 psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1384 psl_req->cmd != DIGITAL_CMD_PSL_REQ) {
1389 dsi = (psl_req->brs >> 3) & 0x07;
1392 rf_tech = NFC_DIGITAL_RF_TECH_106A;
1395 rf_tech = NFC_DIGITAL_RF_TECH_212F;
1398 rf_tech = NFC_DIGITAL_RF_TECH_424F;
1401 pr_err("Unsupported dsi value %d\n", dsi);
1405 payload_bits = DIGITAL_PAYLOAD_FSL_TO_BITS(psl_req->fsl);
1406 payload_size = digital_payload_bits_to_size(payload_bits);
1408 if (!payload_size || (payload_size > min(ddev->local_payload_max,
1409 ddev->remote_payload_max))) {
1414 ddev->local_payload_max = payload_size;
1415 ddev->remote_payload_max = payload_size;
1417 rc = digital_tg_send_psl_res(ddev, psl_req->did, rf_tech);
1423 static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev,
1424 void *arg, struct sk_buff *resp)
1429 digital_poll_next_tech(ddev);
1434 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB)
1437 ddev->atn_count = 0;
1439 if (resp->data[offset] == DIGITAL_CMD_PSL_REQ)
1440 digital_tg_recv_psl_req(ddev, arg, resp);
1442 digital_tg_recv_dep_req(ddev, arg, resp);
1445 static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev,
1446 struct digital_atr_req *atr_req)
1448 struct digital_atr_res *atr_res;
1449 struct sk_buff *skb;
1450 u8 *gb, payload_bits;
1454 gb = nfc_get_local_general_bytes(ddev->nfc_dev, &gb_len);
1458 skb = digital_skb_alloc(ddev, sizeof(struct digital_atr_res) + gb_len);
1462 skb_put(skb, sizeof(struct digital_atr_res));
1463 atr_res = (struct digital_atr_res *)skb->data;
1465 memset(atr_res, 0, sizeof(struct digital_atr_res));
1467 atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1468 atr_res->cmd = DIGITAL_CMD_ATR_RES;
1469 memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3));
1472 ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX;
1473 payload_bits = digital_payload_size_to_bits(ddev->local_payload_max);
1474 atr_res->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits);
1477 skb_put(skb, gb_len);
1479 atr_res->pp |= DIGITAL_GB_BIT;
1480 memcpy(atr_res->gb, gb, gb_len);
1483 digital_skb_push_dep_sod(ddev, skb);
1485 ddev->skb_add_crc(skb);
1487 ddev->curr_nfc_dep_pni = 0;
1489 rc = digital_tg_send_cmd(ddev, skb, 999,
1490 digital_tg_send_atr_res_complete, NULL);
1497 void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg,
1498 struct sk_buff *resp)
1501 struct digital_atr_req *atr_req;
1502 size_t gb_len, min_size;
1503 u8 poll_tech_count, payload_bits;
1516 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) {
1517 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2;
1518 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_106A);
1520 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1;
1521 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_212F);
1524 if (resp->len < min_size) {
1529 ddev->curr_protocol = NFC_PROTO_NFC_DEP_MASK;
1531 rc = ddev->skb_check_crc(resp);
1533 PROTOCOL_ERR("14.4.1.6");
1537 rc = digital_skb_pull_dep_sod(ddev, resp);
1539 PROTOCOL_ERR("14.4.1.2");
1543 atr_req = (struct digital_atr_req *)resp->data;
1545 if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1546 atr_req->cmd != DIGITAL_CMD_ATR_REQ ||
1547 atr_req->did > DIGITAL_DID_MAX) {
1552 payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_req->pp);
1553 ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
1555 if (!ddev->remote_payload_max) {
1560 ddev->did = atr_req->did;
1562 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1563 NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED);
1567 rc = digital_tg_send_atr_res(ddev, atr_req);
1571 gb_len = resp->len - sizeof(struct digital_atr_req);
1573 poll_tech_count = ddev->poll_tech_count;
1574 ddev->poll_tech_count = 0;
1576 rc = nfc_tm_activated(ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
1577 NFC_COMM_PASSIVE, atr_req->gb, gb_len);
1579 ddev->poll_tech_count = poll_tech_count;
1586 digital_poll_next_tech(ddev);
1588 dev_kfree_skb(resp);