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