aboutsummaryrefslogtreecommitdiffstats
path: root/net/nfc/digital_dep.c
diff options
context:
space:
mode:
Diffstat (limited to 'net/nfc/digital_dep.c')
-rw-r--r--net/nfc/digital_dep.c729
1 files changed, 729 insertions, 0 deletions
diff --git a/net/nfc/digital_dep.c b/net/nfc/digital_dep.c
new file mode 100644
index 000000000000..07bbc24fb4c7
--- /dev/null
+++ b/net/nfc/digital_dep.c
@@ -0,0 +1,729 @@
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_FRAME_DIR_OUT 0xD4
21#define DIGITAL_NFC_DEP_FRAME_DIR_IN 0xD5
22
23#define DIGITAL_NFC_DEP_NFCA_SOD_SB 0xF0
24
25#define DIGITAL_CMD_ATR_REQ 0x00
26#define DIGITAL_CMD_ATR_RES 0x01
27#define DIGITAL_CMD_PSL_REQ 0x04
28#define DIGITAL_CMD_PSL_RES 0x05
29#define DIGITAL_CMD_DEP_REQ 0x06
30#define DIGITAL_CMD_DEP_RES 0x07
31
32#define DIGITAL_ATR_REQ_MIN_SIZE 16
33#define DIGITAL_ATR_REQ_MAX_SIZE 64
34
35#define DIGITAL_NFCID3_LEN ((u8)8)
36#define DIGITAL_LR_BITS_PAYLOAD_SIZE_254B 0x30
37#define DIGITAL_GB_BIT 0x02
38
39#define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0)
40
41#define DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT 0x10
42
43#define DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb) \
44 ((pfb) & DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT)
45#define DIGITAL_NFC_DEP_MI_BIT_SET(pfb) ((pfb) & 0x10)
46#define DIGITAL_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08)
47#define DIGITAL_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & 0x04)
48#define DIGITAL_NFC_DEP_PFB_PNI(pfb) ((pfb) & 0x03)
49
50#define DIGITAL_NFC_DEP_PFB_I_PDU 0x00
51#define DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU 0x40
52#define DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU 0x80
53
54struct digital_atr_req {
55 u8 dir;
56 u8 cmd;
57 u8 nfcid3[10];
58 u8 did;
59 u8 bs;
60 u8 br;
61 u8 pp;
62 u8 gb[0];
63} __packed;
64
65struct digital_atr_res {
66 u8 dir;
67 u8 cmd;
68 u8 nfcid3[10];
69 u8 did;
70 u8 bs;
71 u8 br;
72 u8 to;
73 u8 pp;
74 u8 gb[0];
75} __packed;
76
77struct digital_psl_req {
78 u8 dir;
79 u8 cmd;
80 u8 did;
81 u8 brs;
82 u8 fsl;
83} __packed;
84
85struct digital_psl_res {
86 u8 dir;
87 u8 cmd;
88 u8 did;
89} __packed;
90
91struct digital_dep_req_res {
92 u8 dir;
93 u8 cmd;
94 u8 pfb;
95} __packed;
96
97static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
98 struct sk_buff *resp);
99
100static void digital_skb_push_dep_sod(struct nfc_digital_dev *ddev,
101 struct sk_buff *skb)
102{
103 skb_push(skb, sizeof(u8));
104
105 skb->data[0] = skb->len;
106
107 if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
108 *skb_push(skb, sizeof(u8)) = DIGITAL_NFC_DEP_NFCA_SOD_SB;
109}
110
111static int digital_skb_pull_dep_sod(struct nfc_digital_dev *ddev,
112 struct sk_buff *skb)
113{
114 u8 size;
115
116 if (skb->len < 2)
117 return -EIO;
118
119 if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
120 skb_pull(skb, sizeof(u8));
121
122 size = skb->data[0];
123 if (size != skb->len)
124 return -EIO;
125
126 skb_pull(skb, sizeof(u8));
127
128 return 0;
129}
130
131static void digital_in_recv_atr_res(struct nfc_digital_dev *ddev, void *arg,
132 struct sk_buff *resp)
133{
134 struct nfc_target *target = arg;
135 struct digital_atr_res *atr_res;
136 u8 gb_len;
137 int rc;
138
139 if (IS_ERR(resp)) {
140 rc = PTR_ERR(resp);
141 resp = NULL;
142 goto exit;
143 }
144
145 rc = ddev->skb_check_crc(resp);
146 if (rc) {
147 PROTOCOL_ERR("14.4.1.6");
148 goto exit;
149 }
150
151 rc = digital_skb_pull_dep_sod(ddev, resp);
152 if (rc) {
153 PROTOCOL_ERR("14.4.1.2");
154 goto exit;
155 }
156
157 if (resp->len < sizeof(struct digital_atr_res)) {
158 rc = -EIO;
159 goto exit;
160 }
161
162 gb_len = resp->len - sizeof(struct digital_atr_res);
163
164 atr_res = (struct digital_atr_res *)resp->data;
165
166 rc = nfc_set_remote_general_bytes(ddev->nfc_dev, atr_res->gb, gb_len);
167 if (rc)
168 goto exit;
169
170 rc = nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
171 NFC_RF_INITIATOR);
172
173 ddev->curr_nfc_dep_pni = 0;
174
175exit:
176 dev_kfree_skb(resp);
177
178 if (rc)
179 ddev->curr_protocol = 0;
180}
181
182int digital_in_send_atr_req(struct nfc_digital_dev *ddev,
183 struct nfc_target *target, __u8 comm_mode, __u8 *gb,
184 size_t gb_len)
185{
186 struct sk_buff *skb;
187 struct digital_atr_req *atr_req;
188 uint size;
189
190 size = DIGITAL_ATR_REQ_MIN_SIZE + gb_len;
191
192 if (size > DIGITAL_ATR_REQ_MAX_SIZE) {
193 PROTOCOL_ERR("14.6.1.1");
194 return -EINVAL;
195 }
196
197 skb = digital_skb_alloc(ddev, size);
198 if (!skb)
199 return -ENOMEM;
200
201 skb_put(skb, sizeof(struct digital_atr_req));
202
203 atr_req = (struct digital_atr_req *)skb->data;
204 memset(atr_req, 0, sizeof(struct digital_atr_req));
205
206 atr_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
207 atr_req->cmd = DIGITAL_CMD_ATR_REQ;
208 if (target->nfcid2_len)
209 memcpy(atr_req->nfcid3, target->nfcid2,
210 max(target->nfcid2_len, DIGITAL_NFCID3_LEN));
211 else
212 get_random_bytes(atr_req->nfcid3, DIGITAL_NFCID3_LEN);
213
214 atr_req->did = 0;
215 atr_req->bs = 0;
216 atr_req->br = 0;
217
218 atr_req->pp = DIGITAL_LR_BITS_PAYLOAD_SIZE_254B;
219
220 if (gb_len) {
221 atr_req->pp |= DIGITAL_GB_BIT;
222 memcpy(skb_put(skb, gb_len), gb, gb_len);
223 }
224
225 digital_skb_push_dep_sod(ddev, skb);
226
227 ddev->skb_add_crc(skb);
228
229 digital_in_send_cmd(ddev, skb, 500, digital_in_recv_atr_res, target);
230
231 return 0;
232}
233
234static int digital_in_send_rtox(struct nfc_digital_dev *ddev,
235 struct digital_data_exch *data_exch, u8 rtox)
236{
237 struct digital_dep_req_res *dep_req;
238 struct sk_buff *skb;
239 int rc;
240
241 skb = digital_skb_alloc(ddev, 1);
242 if (!skb)
243 return -ENOMEM;
244
245 *skb_put(skb, 1) = rtox;
246
247 skb_push(skb, sizeof(struct digital_dep_req_res));
248
249 dep_req = (struct digital_dep_req_res *)skb->data;
250
251 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
252 dep_req->cmd = DIGITAL_CMD_DEP_REQ;
253 dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU |
254 DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT;
255
256 digital_skb_push_dep_sod(ddev, skb);
257
258 ddev->skb_add_crc(skb);
259
260 rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
261 data_exch);
262
263 return rc;
264}
265
266static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
267 struct sk_buff *resp)
268{
269 struct digital_data_exch *data_exch = arg;
270 struct digital_dep_req_res *dep_res;
271 u8 pfb;
272 uint size;
273 int rc;
274
275 if (IS_ERR(resp)) {
276 rc = PTR_ERR(resp);
277 resp = NULL;
278 goto exit;
279 }
280
281 rc = ddev->skb_check_crc(resp);
282 if (rc) {
283 PROTOCOL_ERR("14.4.1.6");
284 goto error;
285 }
286
287 rc = digital_skb_pull_dep_sod(ddev, resp);
288 if (rc) {
289 PROTOCOL_ERR("14.4.1.2");
290 goto exit;
291 }
292
293 dep_res = (struct digital_dep_req_res *)resp->data;
294
295 if (resp->len < sizeof(struct digital_dep_req_res) ||
296 dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN ||
297 dep_res->cmd != DIGITAL_CMD_DEP_RES) {
298 rc = -EIO;
299 goto error;
300 }
301
302 pfb = dep_res->pfb;
303
304 switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
305 case DIGITAL_NFC_DEP_PFB_I_PDU:
306 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
307 PROTOCOL_ERR("14.12.3.3");
308 rc = -EIO;
309 goto error;
310 }
311
312 ddev->curr_nfc_dep_pni =
313 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
314 rc = 0;
315 break;
316
317 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
318 pr_err("Received a ACK/NACK PDU\n");
319 rc = -EIO;
320 goto error;
321
322 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
323 if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) {
324 rc = -EINVAL;
325 goto error;
326 }
327
328 rc = digital_in_send_rtox(ddev, data_exch, resp->data[3]);
329 if (rc)
330 goto error;
331
332 kfree_skb(resp);
333 return;
334 }
335
336 if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb)) {
337 pr_err("MI bit set. Chained PDU not supported\n");
338 rc = -EIO;
339 goto error;
340 }
341
342 size = sizeof(struct digital_dep_req_res);
343
344 if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb))
345 size++;
346
347 if (size > resp->len) {
348 rc = -EIO;
349 goto error;
350 }
351
352 skb_pull(resp, size);
353
354exit:
355 data_exch->cb(data_exch->cb_context, resp, rc);
356
357error:
358 kfree(data_exch);
359
360 if (rc)
361 kfree_skb(resp);
362}
363
364int digital_in_send_dep_req(struct nfc_digital_dev *ddev,
365 struct nfc_target *target, struct sk_buff *skb,
366 struct digital_data_exch *data_exch)
367{
368 struct digital_dep_req_res *dep_req;
369
370 skb_push(skb, sizeof(struct digital_dep_req_res));
371
372 dep_req = (struct digital_dep_req_res *)skb->data;
373 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
374 dep_req->cmd = DIGITAL_CMD_DEP_REQ;
375 dep_req->pfb = ddev->curr_nfc_dep_pni;
376
377 digital_skb_push_dep_sod(ddev, skb);
378
379 ddev->skb_add_crc(skb);
380
381 return digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
382 data_exch);
383}
384
385static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
386 struct sk_buff *resp)
387{
388 int rc;
389 struct digital_dep_req_res *dep_req;
390 size_t size;
391
392 if (IS_ERR(resp)) {
393 rc = PTR_ERR(resp);
394 resp = NULL;
395 goto exit;
396 }
397
398 rc = ddev->skb_check_crc(resp);
399 if (rc) {
400 PROTOCOL_ERR("14.4.1.6");
401 goto exit;
402 }
403
404 rc = digital_skb_pull_dep_sod(ddev, resp);
405 if (rc) {
406 PROTOCOL_ERR("14.4.1.2");
407 goto exit;
408 }
409
410 size = sizeof(struct digital_dep_req_res);
411 dep_req = (struct digital_dep_req_res *)resp->data;
412
413 if (resp->len < size || dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
414 dep_req->cmd != DIGITAL_CMD_DEP_REQ) {
415 rc = -EIO;
416 goto exit;
417 }
418
419 if (DIGITAL_NFC_DEP_DID_BIT_SET(dep_req->pfb))
420 size++;
421
422 if (resp->len < size) {
423 rc = -EIO;
424 goto exit;
425 }
426
427 switch (DIGITAL_NFC_DEP_PFB_TYPE(dep_req->pfb)) {
428 case DIGITAL_NFC_DEP_PFB_I_PDU:
429 pr_debug("DIGITAL_NFC_DEP_PFB_I_PDU\n");
430 ddev->curr_nfc_dep_pni = DIGITAL_NFC_DEP_PFB_PNI(dep_req->pfb);
431 break;
432 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
433 pr_err("Received a ACK/NACK PDU\n");
434 rc = -EINVAL;
435 goto exit;
436 break;
437 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
438 pr_err("Received a SUPERVISOR PDU\n");
439 rc = -EINVAL;
440 goto exit;
441 break;
442 }
443
444 skb_pull(resp, size);
445
446 rc = nfc_tm_data_received(ddev->nfc_dev, resp);
447
448exit:
449 if (rc)
450 kfree_skb(resp);
451}
452
453int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb)
454{
455 struct digital_dep_req_res *dep_res;
456
457 skb_push(skb, sizeof(struct digital_dep_req_res));
458 dep_res = (struct digital_dep_req_res *)skb->data;
459
460 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
461 dep_res->cmd = DIGITAL_CMD_DEP_RES;
462 dep_res->pfb = ddev->curr_nfc_dep_pni;
463
464 digital_skb_push_dep_sod(ddev, skb);
465
466 ddev->skb_add_crc(skb);
467
468 return digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
469 NULL);
470}
471
472static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev,
473 void *arg, struct sk_buff *resp)
474{
475 u8 rf_tech = PTR_ERR(arg);
476
477 if (IS_ERR(resp))
478 return;
479
480 digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
481
482 digital_tg_listen(ddev, 1500, digital_tg_recv_dep_req, NULL);
483
484 dev_kfree_skb(resp);
485}
486
487static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did,
488 u8 rf_tech)
489{
490 struct digital_psl_res *psl_res;
491 struct sk_buff *skb;
492 int rc;
493
494 skb = digital_skb_alloc(ddev, sizeof(struct digital_psl_res));
495 if (!skb)
496 return -ENOMEM;
497
498 skb_put(skb, sizeof(struct digital_psl_res));
499
500 psl_res = (struct digital_psl_res *)skb->data;
501
502 psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
503 psl_res->cmd = DIGITAL_CMD_PSL_RES;
504 psl_res->did = did;
505
506 digital_skb_push_dep_sod(ddev, skb);
507
508 ddev->skb_add_crc(skb);
509
510 rc = digital_tg_send_cmd(ddev, skb, 0, digital_tg_send_psl_res_complete,
511 ERR_PTR(rf_tech));
512
513 if (rc)
514 kfree_skb(skb);
515
516 return rc;
517}
518
519static void digital_tg_recv_psl_req(struct nfc_digital_dev *ddev, void *arg,
520 struct sk_buff *resp)
521{
522 int rc;
523 struct digital_psl_req *psl_req;
524 u8 rf_tech;
525 u8 dsi;
526
527 if (IS_ERR(resp)) {
528 rc = PTR_ERR(resp);
529 resp = NULL;
530 goto exit;
531 }
532
533 rc = ddev->skb_check_crc(resp);
534 if (rc) {
535 PROTOCOL_ERR("14.4.1.6");
536 goto exit;
537 }
538
539 rc = digital_skb_pull_dep_sod(ddev, resp);
540 if (rc) {
541 PROTOCOL_ERR("14.4.1.2");
542 goto exit;
543 }
544
545 psl_req = (struct digital_psl_req *)resp->data;
546
547 if (resp->len != sizeof(struct digital_psl_req) ||
548 psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
549 psl_req->cmd != DIGITAL_CMD_PSL_REQ) {
550 rc = -EIO;
551 goto exit;
552 }
553
554 dsi = (psl_req->brs >> 3) & 0x07;
555 switch (dsi) {
556 case 0:
557 rf_tech = NFC_DIGITAL_RF_TECH_106A;
558 break;
559 case 1:
560 rf_tech = NFC_DIGITAL_RF_TECH_212F;
561 break;
562 case 2:
563 rf_tech = NFC_DIGITAL_RF_TECH_424F;
564 break;
565 default:
566 pr_err("Unsuported dsi value %d\n", dsi);
567 goto exit;
568 }
569
570 rc = digital_tg_send_psl_res(ddev, psl_req->did, rf_tech);
571
572exit:
573 kfree_skb(resp);
574}
575
576static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev,
577 void *arg, struct sk_buff *resp)
578{
579 int offset;
580
581 if (IS_ERR(resp)) {
582 digital_poll_next_tech(ddev);
583 return;
584 }
585
586 offset = 2;
587 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB)
588 offset++;
589
590 if (resp->data[offset] == DIGITAL_CMD_PSL_REQ)
591 digital_tg_recv_psl_req(ddev, arg, resp);
592 else
593 digital_tg_recv_dep_req(ddev, arg, resp);
594}
595
596static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev,
597 struct digital_atr_req *atr_req)
598{
599 struct digital_atr_res *atr_res;
600 struct sk_buff *skb;
601 u8 *gb;
602 size_t gb_len;
603 int rc;
604
605 gb = nfc_get_local_general_bytes(ddev->nfc_dev, &gb_len);
606 if (!gb)
607 gb_len = 0;
608
609 skb = digital_skb_alloc(ddev, sizeof(struct digital_atr_res) + gb_len);
610 if (!skb)
611 return -ENOMEM;
612
613 skb_put(skb, sizeof(struct digital_atr_res));
614 atr_res = (struct digital_atr_res *)skb->data;
615
616 memset(atr_res, 0, sizeof(struct digital_atr_res));
617
618 atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
619 atr_res->cmd = DIGITAL_CMD_ATR_RES;
620 memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3));
621 atr_res->to = 8;
622 atr_res->pp = DIGITAL_LR_BITS_PAYLOAD_SIZE_254B;
623 if (gb_len) {
624 skb_put(skb, gb_len);
625
626 atr_res->pp |= DIGITAL_GB_BIT;
627 memcpy(atr_res->gb, gb, gb_len);
628 }
629
630 digital_skb_push_dep_sod(ddev, skb);
631
632 ddev->skb_add_crc(skb);
633
634 rc = digital_tg_send_cmd(ddev, skb, 999,
635 digital_tg_send_atr_res_complete, NULL);
636 if (rc) {
637 kfree_skb(skb);
638 return rc;
639 }
640
641 return rc;
642}
643
644void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg,
645 struct sk_buff *resp)
646{
647 int rc;
648 struct digital_atr_req *atr_req;
649 size_t gb_len, min_size;
650
651 if (IS_ERR(resp)) {
652 rc = PTR_ERR(resp);
653 resp = NULL;
654 goto exit;
655 }
656
657 if (!resp->len) {
658 rc = -EIO;
659 goto exit;
660 }
661
662 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) {
663 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2;
664
665 ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_106A;
666 ddev->skb_add_crc = digital_skb_add_crc_a;
667 ddev->skb_check_crc = digital_skb_check_crc_a;
668 } else {
669 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1;
670
671 ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_212F;
672 ddev->skb_add_crc = digital_skb_add_crc_f;
673 ddev->skb_check_crc = digital_skb_check_crc_f;
674 }
675
676 if (resp->len < min_size) {
677 rc = -EIO;
678 goto exit;
679 }
680
681 if (DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
682 ddev->skb_add_crc = digital_skb_add_crc_none;
683 ddev->skb_check_crc = digital_skb_check_crc_none;
684 }
685
686 rc = ddev->skb_check_crc(resp);
687 if (rc) {
688 PROTOCOL_ERR("14.4.1.6");
689 goto exit;
690 }
691
692 rc = digital_skb_pull_dep_sod(ddev, resp);
693 if (rc) {
694 PROTOCOL_ERR("14.4.1.2");
695 goto exit;
696 }
697
698 atr_req = (struct digital_atr_req *)resp->data;
699
700 if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
701 atr_req->cmd != DIGITAL_CMD_ATR_REQ) {
702 rc = -EINVAL;
703 goto exit;
704 }
705
706 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
707 NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED);
708 if (rc)
709 goto exit;
710
711 rc = digital_tg_send_atr_res(ddev, atr_req);
712 if (rc)
713 goto exit;
714
715 gb_len = resp->len - sizeof(struct digital_atr_req);
716 rc = nfc_tm_activated(ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
717 NFC_COMM_PASSIVE, atr_req->gb, gb_len);
718 if (rc)
719 goto exit;
720
721 ddev->poll_tech_count = 0;
722
723 rc = 0;
724exit:
725 if (rc)
726 digital_poll_next_tech(ddev);
727
728 dev_kfree_skb(resp);
729}
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-15 10:46:30 -0500