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