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_CMD_SENS_REQ 0x26
21#define DIGITAL_CMD_ALL_REQ 0x52
22#define DIGITAL_CMD_SEL_REQ_CL1 0x93
23#define DIGITAL_CMD_SEL_REQ_CL2 0x95
24#define DIGITAL_CMD_SEL_REQ_CL3 0x97
25
26#define DIGITAL_SDD_REQ_SEL_PAR 0x20
27
28#define DIGITAL_SDD_RES_CT 0x88
29#define DIGITAL_SDD_RES_LEN 5
30
31#define DIGITAL_SEL_RES_NFCID1_COMPLETE(sel_res) (!((sel_res) & 0x04))
32#define DIGITAL_SEL_RES_IS_T2T(sel_res) (!((sel_res) & 0x60))
33#define DIGITAL_SEL_RES_IS_T4T(sel_res) ((sel_res) & 0x20)
34#define DIGITAL_SEL_RES_IS_NFC_DEP(sel_res) ((sel_res) & 0x40)
35
36#define DIGITAL_SENS_RES_IS_T1T(sens_res) (((sens_res) & 0x0C00) == 0x0C00)
37#define DIGITAL_SENS_RES_IS_VALID(sens_res) \
38 ((!((sens_res) & 0x001F) && (((sens_res) & 0x0C00) == 0x0C00)) || \
39 (((sens_res) & 0x001F) && ((sens_res) & 0x0C00) != 0x0C00))
40
41#define DIGITAL_MIFARE_READ_RES_LEN 16
42#define DIGITAL_MIFARE_ACK_RES 0x0A
43
44#define DIGITAL_CMD_SENSF_REQ 0x00
45#define DIGITAL_CMD_SENSF_RES 0x01
46
47#define DIGITAL_SENSF_RES_MIN_LENGTH 17
48#define DIGITAL_SENSF_RES_RD_AP_B1 0x00
49#define DIGITAL_SENSF_RES_RD_AP_B2 0x8F
50
51#define DIGITAL_SENSF_REQ_RC_NONE 0
52#define DIGITAL_SENSF_REQ_RC_SC 1
53#define DIGITAL_SENSF_REQ_RC_AP 2
54
55#define DIGITAL_CMD_ISO15693_INVENTORY_REQ 0x01
56
57#define DIGITAL_ISO15693_REQ_FLAG_DATA_RATE BIT(1)
58#define DIGITAL_ISO15693_REQ_FLAG_INVENTORY BIT(2)
59#define DIGITAL_ISO15693_REQ_FLAG_NB_SLOTS BIT(5)
60#define DIGITAL_ISO15693_RES_FLAG_ERROR BIT(0)
61#define DIGITAL_ISO15693_RES_IS_VALID(flags) \
62 (!((flags) & DIGITAL_ISO15693_RES_FLAG_ERROR))
63
64#define DIGITAL_ISO_DEP_I_PCB 0x02
65#define DIGITAL_ISO_DEP_PNI(pni) ((pni) & 0x01)
66
67#define DIGITAL_ISO_DEP_PCB_TYPE(pcb) ((pcb) & 0xC0)
68
69#define DIGITAL_ISO_DEP_I_BLOCK 0x00
70
71#define DIGITAL_ISO_DEP_BLOCK_HAS_DID(pcb) ((pcb) & 0x08)
72
73static const u8 digital_ats_fsc[] = {
74 16, 24, 32, 40, 48, 64, 96, 128,
75};
76
77#define DIGITAL_ATS_FSCI(t0) ((t0) & 0x0F)
78#define DIGITAL_ATS_MAX_FSC 256
79
80#define DIGITAL_RATS_BYTE1 0xE0
81#define DIGITAL_RATS_PARAM 0x80
82
83struct digital_sdd_res {
84 u8 nfcid1[4];
85 u8 bcc;
86} __packed;
87
88struct digital_sel_req {
89 u8 sel_cmd;
90 u8 b2;
91 u8 nfcid1[4];
92 u8 bcc;
93} __packed;
94
95struct digital_sensf_req {
96 u8 cmd;
97 u8 sc1;
98 u8 sc2;
99 u8 rc;
100 u8 tsn;
101} __packed;
102
103struct digital_sensf_res {
104 u8 cmd;
105 u8 nfcid2[8];
106 u8 pad0[2];
107 u8 pad1[3];
108 u8 mrti_check;
109 u8 mrti_update;
110 u8 pad2;
111 u8 rd[2];
112} __packed;
113
114struct digital_iso15693_inv_req {
115 u8 flags;
116 u8 cmd;
117 u8 mask_len;
118 u64 mask;
119} __packed;
120
121struct digital_iso15693_inv_res {
122 u8 flags;
123 u8 dsfid;
124 u64 uid;
125} __packed;
126
127static int digital_in_send_sdd_req(struct nfc_digital_dev *ddev,
128 struct nfc_target *target);
129
130int digital_in_iso_dep_pull_sod(struct nfc_digital_dev *ddev,
131 struct sk_buff *skb)
132{
133 u8 pcb;
134 u8 block_type;
135
136 if (skb->len < 1)
137 return -EIO;
138
139 pcb = *skb->data;
140 block_type = DIGITAL_ISO_DEP_PCB_TYPE(pcb);
141
142 /* No support fo R-block nor S-block */
143 if (block_type != DIGITAL_ISO_DEP_I_BLOCK) {
144 pr_err("ISO_DEP R-block and S-block not supported\n");
145 return -EIO;
146 }
147
148 if (DIGITAL_ISO_DEP_BLOCK_HAS_DID(pcb)) {
149 pr_err("DID field in ISO_DEP PCB not supported\n");
150 return -EIO;
151 }
152
153 skb_pull(skb, 1);
154
155 return 0;
156}
157
158int digital_in_iso_dep_push_sod(struct nfc_digital_dev *ddev,
159 struct sk_buff *skb)
160{
161 /*
162 * Chaining not supported so skb->len + 1 PCB byte + 2 CRC bytes must
163 * not be greater than remote FSC
164 */
165 if (skb->len + 3 > ddev->target_fsc)
166 return -EIO;
167
168 skb_push(skb, 1);
169
170 *skb->data = DIGITAL_ISO_DEP_I_PCB | ddev->curr_nfc_dep_pni;
171
172 ddev->curr_nfc_dep_pni =
173 DIGITAL_ISO_DEP_PNI(ddev->curr_nfc_dep_pni + 1);
174
175 return 0;
176}
177
178static void digital_in_recv_ats(struct nfc_digital_dev *ddev, void *arg,
179 struct sk_buff *resp)
180{
181 struct nfc_target *target = arg;
182 u8 fsdi;
183 int rc;
184
185 if (IS_ERR(resp)) {
186 rc = PTR_ERR(resp);
187 resp = NULL;
188 goto exit;
189 }
190
191 if (resp->len < 2) {
192 rc = -EIO;
193 goto exit;
194 }
195
196 fsdi = DIGITAL_ATS_FSCI(resp->data[1]);
197 if (fsdi >= 8)
198 ddev->target_fsc = DIGITAL_ATS_MAX_FSC;
199 else
200 ddev->target_fsc = digital_ats_fsc[fsdi];
201
202 ddev->curr_nfc_dep_pni = 0;
203
204 rc = digital_target_found(ddev, target, NFC_PROTO_ISO14443);
205
206exit:
207 dev_kfree_skb(resp);
208 kfree(target);
209
210 if (rc)
211 digital_poll_next_tech(ddev);
212}
213
214static int digital_in_send_rats(struct nfc_digital_dev *ddev,
215 struct nfc_target *target)
216{
217 int rc;
218 struct sk_buff *skb;
219
220 skb = digital_skb_alloc(ddev, 2);
221 if (!skb)
222 return -ENOMEM;
223
224 *skb_put(skb, 1) = DIGITAL_RATS_BYTE1;
225 *skb_put(skb, 1) = DIGITAL_RATS_PARAM;
226
227 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_ats,
228 target);
229 if (rc)
230 kfree_skb(skb);
231
232 return rc;
233}
234
235static void digital_in_recv_sel_res(struct nfc_digital_dev *ddev, void *arg,
236 struct sk_buff *resp)
237{
238 struct nfc_target *target = arg;
239 int rc;
240 u8 sel_res;
241 u8 nfc_proto;
242
243 if (IS_ERR(resp)) {
244 rc = PTR_ERR(resp);
245 resp = NULL;
246 goto exit;
247 }
248
249 if (!DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
250 rc = digital_skb_check_crc_a(resp);
251 if (rc) {
252 PROTOCOL_ERR("4.4.1.3");
253 goto exit;
254 }
255 }
256
257 if (!resp->len) {
258 rc = -EIO;
259 goto exit;
260 }
261
262 sel_res = resp->data[0];
263
264 if (!DIGITAL_SEL_RES_NFCID1_COMPLETE(sel_res)) {
265 rc = digital_in_send_sdd_req(ddev, target);
266 if (rc)
267 goto exit;
268
269 goto exit_free_skb;
270 }
271
272 target->sel_res = sel_res;
273
274 if (DIGITAL_SEL_RES_IS_T2T(sel_res)) {
275 nfc_proto = NFC_PROTO_MIFARE;
276 } else if (DIGITAL_SEL_RES_IS_T4T(sel_res)) {
277 rc = digital_in_send_rats(ddev, target);
278 if (rc)
279 goto exit;
280 /*
281 * Skip target_found and don't free it for now. This will be
282 * done when receiving the ATS
283 */
284 goto exit_free_skb;
285 } else if (DIGITAL_SEL_RES_IS_NFC_DEP(sel_res)) {
286 nfc_proto = NFC_PROTO_NFC_DEP;
287 } else {
288 rc = -EOPNOTSUPP;
289 goto exit;
290 }
291
292 rc = digital_target_found(ddev, target, nfc_proto);
293
294exit:
295 kfree(target);
296
297exit_free_skb:
298 dev_kfree_skb(resp);
299
300 if (rc)
301 digital_poll_next_tech(ddev);
302}
303
304static int digital_in_send_sel_req(struct nfc_digital_dev *ddev,
305 struct nfc_target *target,
306 struct digital_sdd_res *sdd_res)
307{
308 struct sk_buff *skb;
309 struct digital_sel_req *sel_req;
310 u8 sel_cmd;
311 int rc;
312
313 skb = digital_skb_alloc(ddev, sizeof(struct digital_sel_req));
314 if (!skb)
315 return -ENOMEM;
316
317 skb_put(skb, sizeof(struct digital_sel_req));
318 sel_req = (struct digital_sel_req *)skb->data;
319
320 if (target->nfcid1_len <= 4)
321 sel_cmd = DIGITAL_CMD_SEL_REQ_CL1;
322 else if (target->nfcid1_len < 10)
323 sel_cmd = DIGITAL_CMD_SEL_REQ_CL2;
324 else
325 sel_cmd = DIGITAL_CMD_SEL_REQ_CL3;
326
327 sel_req->sel_cmd = sel_cmd;
328 sel_req->b2 = 0x70;
329 memcpy(sel_req->nfcid1, sdd_res->nfcid1, 4);
330 sel_req->bcc = sdd_res->bcc;
331
332 if (DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
333 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
334 NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A);
335 if (rc)
336 goto exit;
337 } else {
338 digital_skb_add_crc_a(skb);
339 }
340
341 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sel_res,
342 target);
343exit:
344 if (rc)
345 kfree_skb(skb);
346
347 return rc;
348}
349
350static void digital_in_recv_sdd_res(struct nfc_digital_dev *ddev, void *arg,
351 struct sk_buff *resp)
352{
353 struct nfc_target *target = arg;
354 struct digital_sdd_res *sdd_res;
355 int rc;
356 u8 offset, size;
357 u8 i, bcc;
358
359 if (IS_ERR(resp)) {
360 rc = PTR_ERR(resp);
361 resp = NULL;
362 goto exit;
363 }
364
365 if (resp->len < DIGITAL_SDD_RES_LEN) {
366 PROTOCOL_ERR("4.7.2.8");
367 rc = -EINVAL;
368 goto exit;
369 }
370
371 sdd_res = (struct digital_sdd_res *)resp->data;
372
373 for (i = 0, bcc = 0; i < 4; i++)
374 bcc ^= sdd_res->nfcid1[i];
375
376 if (bcc != sdd_res->bcc) {
377 PROTOCOL_ERR("4.7.2.6");
378 rc = -EINVAL;
379 goto exit;
380 }
381
382 if (sdd_res->nfcid1[0] == DIGITAL_SDD_RES_CT) {
383 offset = 1;
384 size = 3;
385 } else {
386 offset = 0;
387 size = 4;
388 }
389
390 memcpy(target->nfcid1 + target->nfcid1_len, sdd_res->nfcid1 + offset,
391 size);
392 target->nfcid1_len += size;
393
394 rc = digital_in_send_sel_req(ddev, target, sdd_res);
395
396exit:
397 dev_kfree_skb(resp);
398
399 if (rc) {
400 kfree(target);
401 digital_poll_next_tech(ddev);
402 }
403}
404
405static int digital_in_send_sdd_req(struct nfc_digital_dev *ddev,
406 struct nfc_target *target)
407{
408 int rc;
409 struct sk_buff *skb;
410 u8 sel_cmd;
411
412 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
413 NFC_DIGITAL_FRAMING_NFCA_STANDARD);
414 if (rc)
415 return rc;
416
417 skb = digital_skb_alloc(ddev, 2);
418 if (!skb)
419 return -ENOMEM;
420
421 if (target->nfcid1_len == 0)
422 sel_cmd = DIGITAL_CMD_SEL_REQ_CL1;
423 else if (target->nfcid1_len == 3)
424 sel_cmd = DIGITAL_CMD_SEL_REQ_CL2;
425 else
426 sel_cmd = DIGITAL_CMD_SEL_REQ_CL3;
427
428 *skb_put(skb, sizeof(u8)) = sel_cmd;
429 *skb_put(skb, sizeof(u8)) = DIGITAL_SDD_REQ_SEL_PAR;
430
431 return digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sdd_res,
432 target);
433}
434
435static void digital_in_recv_sens_res(struct nfc_digital_dev *ddev, void *arg,
436 struct sk_buff *resp)
437{
438 struct nfc_target *target = NULL;
439 int rc;
440
441 if (IS_ERR(resp)) {
442 rc = PTR_ERR(resp);
443 resp = NULL;
444 goto exit;
445 }
446
447 if (resp->len < sizeof(u16)) {
448 rc = -EIO;
449 goto exit;
450 }
451
452 target = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
453 if (!target) {
454 rc = -ENOMEM;
455 goto exit;
456 }
457
458 target->sens_res = __le16_to_cpu(*(__le16 *)resp->data);
459
460 if (!DIGITAL_SENS_RES_IS_VALID(target->sens_res)) {
461 PROTOCOL_ERR("4.6.3.3");
462 rc = -EINVAL;
463 goto exit;
464 }
465
466 if (DIGITAL_SENS_RES_IS_T1T(target->sens_res))
467 rc = digital_target_found(ddev, target, NFC_PROTO_JEWEL);
468 else
469 rc = digital_in_send_sdd_req(ddev, target);
470
471exit:
472 dev_kfree_skb(resp);
473
474 if (rc) {
475 kfree(target);
476 digital_poll_next_tech(ddev);
477 }
478}
479
480int digital_in_send_sens_req(struct nfc_digital_dev *ddev, u8 rf_tech)
481{
482 struct sk_buff *skb;
483 int rc;
484
485 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
486 NFC_DIGITAL_RF_TECH_106A);
487 if (rc)
488 return rc;
489
490 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
491 NFC_DIGITAL_FRAMING_NFCA_SHORT);
492 if (rc)
493 return rc;
494
495 skb = digital_skb_alloc(ddev, 1);
496 if (!skb)
497 return -ENOMEM;
498
499 *skb_put(skb, sizeof(u8)) = DIGITAL_CMD_SENS_REQ;
500
501 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sens_res, NULL);
502 if (rc)
503 kfree_skb(skb);
504
505 return rc;
506}
507
508int digital_in_recv_mifare_res(struct sk_buff *resp)
509{
510 /* Successful READ command response is 16 data bytes + 2 CRC bytes long.
511 * Since the driver can't differentiate a ACK/NACK response from a valid
512 * READ response, the CRC calculation must be handled at digital level
513 * even if the driver supports it for this technology.
514 */
515 if (resp->len == DIGITAL_MIFARE_READ_RES_LEN + DIGITAL_CRC_LEN) {
516 if (digital_skb_check_crc_a(resp)) {
517 PROTOCOL_ERR("9.4.1.2");
518 return -EIO;
519 }
520
521 return 0;
522 }
523
524 /* ACK response (i.e. successful WRITE). */
525 if (resp->len == 1 && resp->data[0] == DIGITAL_MIFARE_ACK_RES) {
526 resp->data[0] = 0;
527 return 0;
528 }
529
530 /* NACK and any other responses are treated as error. */
531 return -EIO;
532}
533
534static void digital_in_recv_sensf_res(struct nfc_digital_dev *ddev, void *arg,
535 struct sk_buff *resp)
536{
537 int rc;
538 u8 proto;
539 struct nfc_target target;
540 struct digital_sensf_res *sensf_res;
541
542 if (IS_ERR(resp)) {
543 rc = PTR_ERR(resp);
544 resp = NULL;
545 goto exit;
546 }
547
548 if (resp->len < DIGITAL_SENSF_RES_MIN_LENGTH) {
549 rc = -EIO;
550 goto exit;
551 }
552
553 if (!DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
554 rc = digital_skb_check_crc_f(resp);
555 if (rc) {
556 PROTOCOL_ERR("6.4.1.8");
557 goto exit;
558 }
559 }
560
561 skb_pull(resp, 1);
562
563 memset(&target, 0, sizeof(struct nfc_target));
564
565 sensf_res = (struct digital_sensf_res *)resp->data;
566
567 memcpy(target.sensf_res, sensf_res, resp->len);
568 target.sensf_res_len = resp->len;
569
570 memcpy(target.nfcid2, sensf_res->nfcid2, NFC_NFCID2_MAXSIZE);
571 target.nfcid2_len = NFC_NFCID2_MAXSIZE;
572
573 if (target.nfcid2[0] == DIGITAL_SENSF_NFCID2_NFC_DEP_B1 &&
574 target.nfcid2[1] == DIGITAL_SENSF_NFCID2_NFC_DEP_B2)
575 proto = NFC_PROTO_NFC_DEP;
576 else
577 proto = NFC_PROTO_FELICA;
578
579 rc = digital_target_found(ddev, &target, proto);
580
581exit:
582 dev_kfree_skb(resp);
583
584 if (rc)
585 digital_poll_next_tech(ddev);
586}
587
588int digital_in_send_sensf_req(struct nfc_digital_dev *ddev, u8 rf_tech)
589{
590 struct digital_sensf_req *sensf_req;
591 struct sk_buff *skb;
592 int rc;
593 u8 size;
594
595 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
596 if (rc)
597 return rc;
598
599 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
600 NFC_DIGITAL_FRAMING_NFCF);
601 if (rc)
602 return rc;
603
604 size = sizeof(struct digital_sensf_req);
605
606 skb = digital_skb_alloc(ddev, size);
607 if (!skb)
608 return -ENOMEM;
609
610 skb_put(skb, size);
611
612 sensf_req = (struct digital_sensf_req *)skb->data;
613 sensf_req->cmd = DIGITAL_CMD_SENSF_REQ;
614 sensf_req->sc1 = 0xFF;
615 sensf_req->sc2 = 0xFF;
616 sensf_req->rc = 0;
617 sensf_req->tsn = 0;
618
619 *skb_push(skb, 1) = size + 1;
620
621 if (!DIGITAL_DRV_CAPS_IN_CRC(ddev))
622 digital_skb_add_crc_f(skb);
623
624 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sensf_res,
625 NULL);
626 if (rc)
627 kfree_skb(skb);
628
629 return rc;
630}
631
632static void digital_in_recv_iso15693_inv_res(struct nfc_digital_dev *ddev,
633 void *arg, struct sk_buff *resp)
634{
635 struct digital_iso15693_inv_res *res;
636 struct nfc_target *target = NULL;
637 int rc;
638
639 if (IS_ERR(resp)) {
640 rc = PTR_ERR(resp);
641 resp = NULL;
642 goto out_free_skb;
643 }
644
645 if (resp->len != sizeof(*res)) {
646 rc = -EIO;
647 goto out_free_skb;
648 }
649
650 res = (struct digital_iso15693_inv_res *)resp->data;
651
652 if (!DIGITAL_ISO15693_RES_IS_VALID(res->flags)) {
653 PROTOCOL_ERR("ISO15693 - 10.3.1");
654 rc = -EINVAL;
655 goto out_free_skb;
656 }
657
658 target = kzalloc(sizeof(*target), GFP_KERNEL);
659 if (!target) {
660 rc = -ENOMEM;
661 goto out_free_skb;
662 }
663
664 target->is_iso15693 = 1;
665 target->iso15693_dsfid = res->dsfid;
666 memcpy(target->iso15693_uid, &res->uid, sizeof(target->iso15693_uid));
667
668 rc = digital_target_found(ddev, target, NFC_PROTO_ISO15693);
669
670 kfree(target);
671
672out_free_skb:
673 dev_kfree_skb(resp);
674
675 if (rc)
676 digital_poll_next_tech(ddev);
677}
678
679int digital_in_send_iso15693_inv_req(struct nfc_digital_dev *ddev, u8 rf_tech)
680{
681 struct digital_iso15693_inv_req *req;
682 struct sk_buff *skb;
683 int rc;
684
685 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
686 NFC_DIGITAL_RF_TECH_ISO15693);
687 if (rc)
688 return rc;
689
690 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
691 NFC_DIGITAL_FRAMING_ISO15693_INVENTORY);
692 if (rc)
693 return rc;
694
695 skb = digital_skb_alloc(ddev, sizeof(*req));
696 if (!skb)
697 return -ENOMEM;
698
699 skb_put(skb, sizeof(*req) - sizeof(req->mask)); /* No mask */
700 req = (struct digital_iso15693_inv_req *)skb->data;
701
702 /* Single sub-carrier, high data rate, no AFI, single slot
703 * Inventory command
704 */
705 req->flags = DIGITAL_ISO15693_REQ_FLAG_DATA_RATE |
706 DIGITAL_ISO15693_REQ_FLAG_INVENTORY |
707 DIGITAL_ISO15693_REQ_FLAG_NB_SLOTS;
708 req->cmd = DIGITAL_CMD_ISO15693_INVENTORY_REQ;
709 req->mask_len = 0;
710
711 rc = digital_in_send_cmd(ddev, skb, 30,
712 digital_in_recv_iso15693_inv_res, NULL);
713 if (rc)
714 kfree_skb(skb);
715
716 return rc;
717}
718
719static int digital_tg_send_sel_res(struct nfc_digital_dev *ddev)
720{
721 struct sk_buff *skb;
722 int rc;
723
724 skb = digital_skb_alloc(ddev, 1);
725 if (!skb)
726 return -ENOMEM;
727
728 *skb_put(skb, 1) = DIGITAL_SEL_RES_NFC_DEP;
729
730 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev))
731 digital_skb_add_crc_a(skb);
732
733 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_atr_req,
734 NULL);
735 if (rc)
736 kfree_skb(skb);
737
738 return rc;
739}
740
741static void digital_tg_recv_sel_req(struct nfc_digital_dev *ddev, void *arg,
742 struct sk_buff *resp)
743{
744 int rc;
745
746 if (IS_ERR(resp)) {
747 rc = PTR_ERR(resp);
748 resp = NULL;
749 goto exit;
750 }
751
752 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
753 rc = digital_skb_check_crc_a(resp);
754 if (rc) {
755 PROTOCOL_ERR("4.4.1.3");
756 goto exit;
757 }
758 }
759
760 /* Silently ignore SEL_REQ content and send a SEL_RES for NFC-DEP */
761
762 rc = digital_tg_send_sel_res(ddev);
763
764exit:
765 if (rc)
766 digital_poll_next_tech(ddev);
767
768 dev_kfree_skb(resp);
769}
770
771static int digital_tg_send_sdd_res(struct nfc_digital_dev *ddev)
772{
773 struct sk_buff *skb;
774 struct digital_sdd_res *sdd_res;
775 int rc, i;
776
777 skb = digital_skb_alloc(ddev, sizeof(struct digital_sdd_res));
778 if (!skb)
779 return -ENOMEM;
780
781 skb_put(skb, sizeof(struct digital_sdd_res));
782 sdd_res = (struct digital_sdd_res *)skb->data;
783
784 sdd_res->nfcid1[0] = 0x08;
785 get_random_bytes(sdd_res->nfcid1 + 1, 3);
786
787 sdd_res->bcc = 0;
788 for (i = 0; i < 4; i++)
789 sdd_res->bcc ^= sdd_res->nfcid1[i];
790
791 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sel_req,
792 NULL);
793 if (rc)
794 kfree_skb(skb);
795
796 return rc;
797}
798
799static void digital_tg_recv_sdd_req(struct nfc_digital_dev *ddev, void *arg,
800 struct sk_buff *resp)
801{
802 u8 *sdd_req;
803 int rc;
804
805 if (IS_ERR(resp)) {
806 rc = PTR_ERR(resp);
807 resp = NULL;
808 goto exit;
809 }
810
811 sdd_req = resp->data;
812
813 if (resp->len < 2 || sdd_req[0] != DIGITAL_CMD_SEL_REQ_CL1 ||
814 sdd_req[1] != DIGITAL_SDD_REQ_SEL_PAR) {
815 rc = -EINVAL;
816 goto exit;
817 }
818
819 rc = digital_tg_send_sdd_res(ddev);
820
821exit:
822 if (rc)
823 digital_poll_next_tech(ddev);
824
825 dev_kfree_skb(resp);
826}
827
828static int digital_tg_send_sens_res(struct nfc_digital_dev *ddev)
829{
830 struct sk_buff *skb;
831 u8 *sens_res;
832 int rc;
833
834 skb = digital_skb_alloc(ddev, 2);
835 if (!skb)
836 return -ENOMEM;
837
838 sens_res = skb_put(skb, 2);
839
840 sens_res[0] = (DIGITAL_SENS_RES_NFC_DEP >> 8) & 0xFF;
841 sens_res[1] = DIGITAL_SENS_RES_NFC_DEP & 0xFF;
842
843 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sdd_req,
844 NULL);
845 if (rc)
846 kfree_skb(skb);
847
848 return rc;
849}
850
851void digital_tg_recv_sens_req(struct nfc_digital_dev *ddev, void *arg,
852 struct sk_buff *resp)
853{
854 u8 sens_req;
855 int rc;
856
857 if (IS_ERR(resp)) {
858 rc = PTR_ERR(resp);
859 resp = NULL;
860 goto exit;
861 }
862
863 sens_req = resp->data[0];
864
865 if (!resp->len || (sens_req != DIGITAL_CMD_SENS_REQ &&
866 sens_req != DIGITAL_CMD_ALL_REQ)) {
867 rc = -EINVAL;
868 goto exit;
869 }
870
871 rc = digital_tg_send_sens_res(ddev);
872
873exit:
874 if (rc)
875 digital_poll_next_tech(ddev);
876
877 dev_kfree_skb(resp);
878}
879
880static int digital_tg_send_sensf_res(struct nfc_digital_dev *ddev,
881 struct digital_sensf_req *sensf_req)
882{
883 struct sk_buff *skb;
884 u8 size;
885 int rc;
886 struct digital_sensf_res *sensf_res;
887
888 size = sizeof(struct digital_sensf_res);
889
890 if (sensf_req->rc != DIGITAL_SENSF_REQ_RC_NONE)
891 size -= sizeof(sensf_res->rd);
892
893 skb = digital_skb_alloc(ddev, size);
894 if (!skb)
895 return -ENOMEM;
896
897 skb_put(skb, size);
898
899 sensf_res = (struct digital_sensf_res *)skb->data;
900
901 memset(sensf_res, 0, size);
902
903 sensf_res->cmd = DIGITAL_CMD_SENSF_RES;
904 sensf_res->nfcid2[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1;
905 sensf_res->nfcid2[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2;
906 get_random_bytes(&sensf_res->nfcid2[2], 6);
907
908 switch (sensf_req->rc) {
909 case DIGITAL_SENSF_REQ_RC_SC:
910 sensf_res->rd[0] = sensf_req->sc1;
911 sensf_res->rd[1] = sensf_req->sc2;
912 break;
913 case DIGITAL_SENSF_REQ_RC_AP:
914 sensf_res->rd[0] = DIGITAL_SENSF_RES_RD_AP_B1;
915 sensf_res->rd[1] = DIGITAL_SENSF_RES_RD_AP_B2;
916 break;
917 }
918
919 *skb_push(skb, sizeof(u8)) = size + 1;
920
921 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev))
922 digital_skb_add_crc_f(skb);
923
924 rc = digital_tg_send_cmd(ddev, skb, 300,
925 digital_tg_recv_atr_req, NULL);
926 if (rc)
927 kfree_skb(skb);
928
929 return rc;
930}
931
932void digital_tg_recv_sensf_req(struct nfc_digital_dev *ddev, void *arg,
933 struct sk_buff *resp)
934{
935 struct digital_sensf_req *sensf_req;
936 int rc;
937
938 if (IS_ERR(resp)) {
939 rc = PTR_ERR(resp);
940 resp = NULL;
941 goto exit;
942 }
943
944 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
945 rc = digital_skb_check_crc_f(resp);
946 if (rc) {
947 PROTOCOL_ERR("6.4.1.8");
948 goto exit;
949 }
950 }
951
952 if (resp->len != sizeof(struct digital_sensf_req) + 1) {
953 rc = -EINVAL;
954 goto exit;
955 }
956
957 skb_pull(resp, 1);
958 sensf_req = (struct digital_sensf_req *)resp->data;
959
960 if (sensf_req->cmd != DIGITAL_CMD_SENSF_REQ) {
961 rc = -EINVAL;
962 goto exit;
963 }
964
965 rc = digital_tg_send_sensf_res(ddev, sensf_req);
966
967exit:
968 if (rc)
969 digital_poll_next_tech(ddev);
970
971 dev_kfree_skb(resp);
972}
973
974int digital_tg_listen_nfca(struct nfc_digital_dev *ddev, u8 rf_tech)
975{
976 int rc;
977
978 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
979 if (rc)
980 return rc;
981
982 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
983 NFC_DIGITAL_FRAMING_NFCA_NFC_DEP);
984 if (rc)
985 return rc;
986
987 return digital_tg_listen(ddev, 300, digital_tg_recv_sens_req, NULL);
988}
989
990int digital_tg_listen_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech)
991{
992 int rc;
993 u8 *nfcid2;
994
995 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
996 if (rc)
997 return rc;
998
999 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1000 NFC_DIGITAL_FRAMING_NFCF_NFC_DEP);
1001 if (rc)
1002 return rc;
1003
1004 nfcid2 = kzalloc(NFC_NFCID2_MAXSIZE, GFP_KERNEL);
1005 if (!nfcid2)
1006 return -ENOMEM;
1007
1008 nfcid2[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1;
1009 nfcid2[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2;
1010 get_random_bytes(nfcid2 + 2, NFC_NFCID2_MAXSIZE - 2);
1011
1012 return digital_tg_listen(ddev, 300, digital_tg_recv_sensf_req, nfcid2);
1013}
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_CMD_SENS_REQ 0x26
12#define DIGITAL_CMD_ALL_REQ 0x52
13#define DIGITAL_CMD_SEL_REQ_CL1 0x93
14#define DIGITAL_CMD_SEL_REQ_CL2 0x95
15#define DIGITAL_CMD_SEL_REQ_CL3 0x97
16
17#define DIGITAL_SDD_REQ_SEL_PAR 0x20
18
19#define DIGITAL_SDD_RES_CT 0x88
20#define DIGITAL_SDD_RES_LEN 5
21#define DIGITAL_SEL_RES_LEN 1
22
23#define DIGITAL_SEL_RES_NFCID1_COMPLETE(sel_res) (!((sel_res) & 0x04))
24#define DIGITAL_SEL_RES_IS_T2T(sel_res) (!((sel_res) & 0x60))
25#define DIGITAL_SEL_RES_IS_T4T(sel_res) ((sel_res) & 0x20)
26#define DIGITAL_SEL_RES_IS_NFC_DEP(sel_res) ((sel_res) & 0x40)
27
28#define DIGITAL_SENS_RES_IS_T1T(sens_res) (((sens_res) & 0x0C00) == 0x0C00)
29#define DIGITAL_SENS_RES_IS_VALID(sens_res) \
30 ((!((sens_res) & 0x001F) && (((sens_res) & 0x0C00) == 0x0C00)) || \
31 (((sens_res) & 0x001F) && ((sens_res) & 0x0C00) != 0x0C00))
32
33#define DIGITAL_MIFARE_READ_RES_LEN 16
34#define DIGITAL_MIFARE_ACK_RES 0x0A
35
36#define DIGITAL_CMD_SENSB_REQ 0x05
37#define DIGITAL_SENSB_ADVANCED BIT(5)
38#define DIGITAL_SENSB_EXTENDED BIT(4)
39#define DIGITAL_SENSB_ALLB_REQ BIT(3)
40#define DIGITAL_SENSB_N(n) ((n) & 0x7)
41
42#define DIGITAL_CMD_SENSB_RES 0x50
43
44#define DIGITAL_CMD_ATTRIB_REQ 0x1D
45#define DIGITAL_ATTRIB_P1_TR0_DEFAULT (0x0 << 6)
46#define DIGITAL_ATTRIB_P1_TR1_DEFAULT (0x0 << 4)
47#define DIGITAL_ATTRIB_P1_SUPRESS_EOS BIT(3)
48#define DIGITAL_ATTRIB_P1_SUPRESS_SOS BIT(2)
49#define DIGITAL_ATTRIB_P2_LISTEN_POLL_1 (0x0 << 6)
50#define DIGITAL_ATTRIB_P2_POLL_LISTEN_1 (0x0 << 4)
51#define DIGITAL_ATTRIB_P2_MAX_FRAME_256 0x8
52#define DIGITAL_ATTRIB_P4_DID(n) ((n) & 0xf)
53
54#define DIGITAL_CMD_SENSF_REQ 0x00
55#define DIGITAL_CMD_SENSF_RES 0x01
56
57#define DIGITAL_SENSF_RES_MIN_LENGTH 17
58#define DIGITAL_SENSF_RES_RD_AP_B1 0x00
59#define DIGITAL_SENSF_RES_RD_AP_B2 0x8F
60
61#define DIGITAL_SENSF_REQ_RC_NONE 0
62#define DIGITAL_SENSF_REQ_RC_SC 1
63#define DIGITAL_SENSF_REQ_RC_AP 2
64
65#define DIGITAL_CMD_ISO15693_INVENTORY_REQ 0x01
66
67#define DIGITAL_ISO15693_REQ_FLAG_DATA_RATE BIT(1)
68#define DIGITAL_ISO15693_REQ_FLAG_INVENTORY BIT(2)
69#define DIGITAL_ISO15693_REQ_FLAG_NB_SLOTS BIT(5)
70#define DIGITAL_ISO15693_RES_FLAG_ERROR BIT(0)
71#define DIGITAL_ISO15693_RES_IS_VALID(flags) \
72 (!((flags) & DIGITAL_ISO15693_RES_FLAG_ERROR))
73
74#define DIGITAL_ISO_DEP_I_PCB 0x02
75#define DIGITAL_ISO_DEP_PNI(pni) ((pni) & 0x01)
76
77#define DIGITAL_ISO_DEP_PCB_TYPE(pcb) ((pcb) & 0xC0)
78
79#define DIGITAL_ISO_DEP_I_BLOCK 0x00
80
81#define DIGITAL_ISO_DEP_BLOCK_HAS_DID(pcb) ((pcb) & 0x08)
82
83static const u8 digital_ats_fsc[] = {
84 16, 24, 32, 40, 48, 64, 96, 128,
85};
86
87#define DIGITAL_ATS_FSCI(t0) ((t0) & 0x0F)
88#define DIGITAL_SENSB_FSCI(pi2) (((pi2) & 0xF0) >> 4)
89#define DIGITAL_ATS_MAX_FSC 256
90
91#define DIGITAL_RATS_BYTE1 0xE0
92#define DIGITAL_RATS_PARAM 0x80
93
94struct digital_sdd_res {
95 u8 nfcid1[4];
96 u8 bcc;
97} __packed;
98
99struct digital_sel_req {
100 u8 sel_cmd;
101 u8 b2;
102 u8 nfcid1[4];
103 u8 bcc;
104} __packed;
105
106struct digital_sensb_req {
107 u8 cmd;
108 u8 afi;
109 u8 param;
110} __packed;
111
112struct digital_sensb_res {
113 u8 cmd;
114 u8 nfcid0[4];
115 u8 app_data[4];
116 u8 proto_info[3];
117} __packed;
118
119struct digital_attrib_req {
120 u8 cmd;
121 u8 nfcid0[4];
122 u8 param1;
123 u8 param2;
124 u8 param3;
125 u8 param4;
126} __packed;
127
128struct digital_attrib_res {
129 u8 mbli_did;
130} __packed;
131
132struct digital_sensf_req {
133 u8 cmd;
134 u8 sc1;
135 u8 sc2;
136 u8 rc;
137 u8 tsn;
138} __packed;
139
140struct digital_sensf_res {
141 u8 cmd;
142 u8 nfcid2[8];
143 u8 pad0[2];
144 u8 pad1[3];
145 u8 mrti_check;
146 u8 mrti_update;
147 u8 pad2;
148 u8 rd[2];
149} __packed;
150
151struct digital_iso15693_inv_req {
152 u8 flags;
153 u8 cmd;
154 u8 mask_len;
155 u64 mask;
156} __packed;
157
158struct digital_iso15693_inv_res {
159 u8 flags;
160 u8 dsfid;
161 u64 uid;
162} __packed;
163
164static int digital_in_send_sdd_req(struct nfc_digital_dev *ddev,
165 struct nfc_target *target);
166
167int digital_in_iso_dep_pull_sod(struct nfc_digital_dev *ddev,
168 struct sk_buff *skb)
169{
170 u8 pcb;
171 u8 block_type;
172
173 if (skb->len < 1)
174 return -EIO;
175
176 pcb = *skb->data;
177 block_type = DIGITAL_ISO_DEP_PCB_TYPE(pcb);
178
179 /* No support fo R-block nor S-block */
180 if (block_type != DIGITAL_ISO_DEP_I_BLOCK) {
181 pr_err("ISO_DEP R-block and S-block not supported\n");
182 return -EIO;
183 }
184
185 if (DIGITAL_ISO_DEP_BLOCK_HAS_DID(pcb)) {
186 pr_err("DID field in ISO_DEP PCB not supported\n");
187 return -EIO;
188 }
189
190 skb_pull(skb, 1);
191
192 return 0;
193}
194
195int digital_in_iso_dep_push_sod(struct nfc_digital_dev *ddev,
196 struct sk_buff *skb)
197{
198 /*
199 * Chaining not supported so skb->len + 1 PCB byte + 2 CRC bytes must
200 * not be greater than remote FSC
201 */
202 if (skb->len + 3 > ddev->target_fsc)
203 return -EIO;
204
205 skb_push(skb, 1);
206
207 *skb->data = DIGITAL_ISO_DEP_I_PCB | ddev->curr_nfc_dep_pni;
208
209 ddev->curr_nfc_dep_pni =
210 DIGITAL_ISO_DEP_PNI(ddev->curr_nfc_dep_pni + 1);
211
212 return 0;
213}
214
215static void digital_in_recv_ats(struct nfc_digital_dev *ddev, void *arg,
216 struct sk_buff *resp)
217{
218 struct nfc_target *target = arg;
219 u8 fsdi;
220 int rc;
221
222 if (IS_ERR(resp)) {
223 rc = PTR_ERR(resp);
224 resp = NULL;
225 goto exit;
226 }
227
228 if (resp->len < 2) {
229 rc = -EIO;
230 goto exit;
231 }
232
233 fsdi = DIGITAL_ATS_FSCI(resp->data[1]);
234 if (fsdi >= 8)
235 ddev->target_fsc = DIGITAL_ATS_MAX_FSC;
236 else
237 ddev->target_fsc = digital_ats_fsc[fsdi];
238
239 ddev->curr_nfc_dep_pni = 0;
240
241 rc = digital_target_found(ddev, target, NFC_PROTO_ISO14443);
242
243exit:
244 dev_kfree_skb(resp);
245 kfree(target);
246
247 if (rc)
248 digital_poll_next_tech(ddev);
249}
250
251static int digital_in_send_rats(struct nfc_digital_dev *ddev,
252 struct nfc_target *target)
253{
254 int rc;
255 struct sk_buff *skb;
256
257 skb = digital_skb_alloc(ddev, 2);
258 if (!skb)
259 return -ENOMEM;
260
261 skb_put_u8(skb, DIGITAL_RATS_BYTE1);
262 skb_put_u8(skb, DIGITAL_RATS_PARAM);
263
264 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_ats,
265 target);
266 if (rc)
267 kfree_skb(skb);
268
269 return rc;
270}
271
272static void digital_in_recv_sel_res(struct nfc_digital_dev *ddev, void *arg,
273 struct sk_buff *resp)
274{
275 struct nfc_target *target = arg;
276 int rc;
277 u8 sel_res;
278 u8 nfc_proto;
279
280 if (IS_ERR(resp)) {
281 rc = PTR_ERR(resp);
282 resp = NULL;
283 goto exit;
284 }
285
286 if (!DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
287 rc = digital_skb_check_crc_a(resp);
288 if (rc) {
289 PROTOCOL_ERR("4.4.1.3");
290 goto exit;
291 }
292 }
293
294 if (resp->len != DIGITAL_SEL_RES_LEN) {
295 rc = -EIO;
296 goto exit;
297 }
298
299 sel_res = resp->data[0];
300
301 if (!DIGITAL_SEL_RES_NFCID1_COMPLETE(sel_res)) {
302 rc = digital_in_send_sdd_req(ddev, target);
303 if (rc)
304 goto exit;
305
306 goto exit_free_skb;
307 }
308
309 target->sel_res = sel_res;
310
311 if (DIGITAL_SEL_RES_IS_T2T(sel_res)) {
312 nfc_proto = NFC_PROTO_MIFARE;
313 } else if (DIGITAL_SEL_RES_IS_NFC_DEP(sel_res)) {
314 nfc_proto = NFC_PROTO_NFC_DEP;
315 } else if (DIGITAL_SEL_RES_IS_T4T(sel_res)) {
316 rc = digital_in_send_rats(ddev, target);
317 if (rc)
318 goto exit;
319 /*
320 * Skip target_found and don't free it for now. This will be
321 * done when receiving the ATS
322 */
323 goto exit_free_skb;
324 } else {
325 rc = -EOPNOTSUPP;
326 goto exit;
327 }
328
329 rc = digital_target_found(ddev, target, nfc_proto);
330
331exit:
332 kfree(target);
333
334exit_free_skb:
335 dev_kfree_skb(resp);
336
337 if (rc)
338 digital_poll_next_tech(ddev);
339}
340
341static int digital_in_send_sel_req(struct nfc_digital_dev *ddev,
342 struct nfc_target *target,
343 struct digital_sdd_res *sdd_res)
344{
345 struct sk_buff *skb;
346 struct digital_sel_req *sel_req;
347 u8 sel_cmd;
348 int rc;
349
350 skb = digital_skb_alloc(ddev, sizeof(struct digital_sel_req));
351 if (!skb)
352 return -ENOMEM;
353
354 skb_put(skb, sizeof(struct digital_sel_req));
355 sel_req = (struct digital_sel_req *)skb->data;
356
357 if (target->nfcid1_len <= 4)
358 sel_cmd = DIGITAL_CMD_SEL_REQ_CL1;
359 else if (target->nfcid1_len < 10)
360 sel_cmd = DIGITAL_CMD_SEL_REQ_CL2;
361 else
362 sel_cmd = DIGITAL_CMD_SEL_REQ_CL3;
363
364 sel_req->sel_cmd = sel_cmd;
365 sel_req->b2 = 0x70;
366 memcpy(sel_req->nfcid1, sdd_res->nfcid1, 4);
367 sel_req->bcc = sdd_res->bcc;
368
369 if (DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
370 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
371 NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A);
372 if (rc)
373 goto exit;
374 } else {
375 digital_skb_add_crc_a(skb);
376 }
377
378 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sel_res,
379 target);
380exit:
381 if (rc)
382 kfree_skb(skb);
383
384 return rc;
385}
386
387static void digital_in_recv_sdd_res(struct nfc_digital_dev *ddev, void *arg,
388 struct sk_buff *resp)
389{
390 struct nfc_target *target = arg;
391 struct digital_sdd_res *sdd_res;
392 int rc;
393 u8 offset, size;
394 u8 i, bcc;
395
396 if (IS_ERR(resp)) {
397 rc = PTR_ERR(resp);
398 resp = NULL;
399 goto exit;
400 }
401
402 if (resp->len < DIGITAL_SDD_RES_LEN) {
403 PROTOCOL_ERR("4.7.2.8");
404 rc = -EINVAL;
405 goto exit;
406 }
407
408 sdd_res = (struct digital_sdd_res *)resp->data;
409
410 for (i = 0, bcc = 0; i < 4; i++)
411 bcc ^= sdd_res->nfcid1[i];
412
413 if (bcc != sdd_res->bcc) {
414 PROTOCOL_ERR("4.7.2.6");
415 rc = -EINVAL;
416 goto exit;
417 }
418
419 if (sdd_res->nfcid1[0] == DIGITAL_SDD_RES_CT) {
420 offset = 1;
421 size = 3;
422 } else {
423 offset = 0;
424 size = 4;
425 }
426
427 memcpy(target->nfcid1 + target->nfcid1_len, sdd_res->nfcid1 + offset,
428 size);
429 target->nfcid1_len += size;
430
431 rc = digital_in_send_sel_req(ddev, target, sdd_res);
432
433exit:
434 dev_kfree_skb(resp);
435
436 if (rc) {
437 kfree(target);
438 digital_poll_next_tech(ddev);
439 }
440}
441
442static int digital_in_send_sdd_req(struct nfc_digital_dev *ddev,
443 struct nfc_target *target)
444{
445 int rc;
446 struct sk_buff *skb;
447 u8 sel_cmd;
448
449 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
450 NFC_DIGITAL_FRAMING_NFCA_STANDARD);
451 if (rc)
452 return rc;
453
454 skb = digital_skb_alloc(ddev, 2);
455 if (!skb)
456 return -ENOMEM;
457
458 if (target->nfcid1_len == 0)
459 sel_cmd = DIGITAL_CMD_SEL_REQ_CL1;
460 else if (target->nfcid1_len == 3)
461 sel_cmd = DIGITAL_CMD_SEL_REQ_CL2;
462 else
463 sel_cmd = DIGITAL_CMD_SEL_REQ_CL3;
464
465 skb_put_u8(skb, sel_cmd);
466 skb_put_u8(skb, DIGITAL_SDD_REQ_SEL_PAR);
467
468 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sdd_res,
469 target);
470 if (rc)
471 kfree_skb(skb);
472
473 return rc;
474}
475
476static void digital_in_recv_sens_res(struct nfc_digital_dev *ddev, void *arg,
477 struct sk_buff *resp)
478{
479 struct nfc_target *target = NULL;
480 int rc;
481
482 if (IS_ERR(resp)) {
483 rc = PTR_ERR(resp);
484 resp = NULL;
485 goto exit;
486 }
487
488 if (resp->len < sizeof(u16)) {
489 rc = -EIO;
490 goto exit;
491 }
492
493 target = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
494 if (!target) {
495 rc = -ENOMEM;
496 goto exit;
497 }
498
499 target->sens_res = __le16_to_cpu(*(__le16 *)resp->data);
500
501 if (!DIGITAL_SENS_RES_IS_VALID(target->sens_res)) {
502 PROTOCOL_ERR("4.6.3.3");
503 rc = -EINVAL;
504 goto exit;
505 }
506
507 if (DIGITAL_SENS_RES_IS_T1T(target->sens_res))
508 rc = digital_target_found(ddev, target, NFC_PROTO_JEWEL);
509 else
510 rc = digital_in_send_sdd_req(ddev, target);
511
512exit:
513 dev_kfree_skb(resp);
514
515 if (rc) {
516 kfree(target);
517 digital_poll_next_tech(ddev);
518 }
519}
520
521int digital_in_send_sens_req(struct nfc_digital_dev *ddev, u8 rf_tech)
522{
523 struct sk_buff *skb;
524 int rc;
525
526 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
527 NFC_DIGITAL_RF_TECH_106A);
528 if (rc)
529 return rc;
530
531 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
532 NFC_DIGITAL_FRAMING_NFCA_SHORT);
533 if (rc)
534 return rc;
535
536 skb = digital_skb_alloc(ddev, 1);
537 if (!skb)
538 return -ENOMEM;
539
540 skb_put_u8(skb, DIGITAL_CMD_SENS_REQ);
541
542 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sens_res, NULL);
543 if (rc)
544 kfree_skb(skb);
545
546 return rc;
547}
548
549int digital_in_recv_mifare_res(struct sk_buff *resp)
550{
551 /* Successful READ command response is 16 data bytes + 2 CRC bytes long.
552 * Since the driver can't differentiate a ACK/NACK response from a valid
553 * READ response, the CRC calculation must be handled at digital level
554 * even if the driver supports it for this technology.
555 */
556 if (resp->len == DIGITAL_MIFARE_READ_RES_LEN + DIGITAL_CRC_LEN) {
557 if (digital_skb_check_crc_a(resp)) {
558 PROTOCOL_ERR("9.4.1.2");
559 return -EIO;
560 }
561
562 return 0;
563 }
564
565 /* ACK response (i.e. successful WRITE). */
566 if (resp->len == 1 && resp->data[0] == DIGITAL_MIFARE_ACK_RES) {
567 resp->data[0] = 0;
568 return 0;
569 }
570
571 /* NACK and any other responses are treated as error. */
572 return -EIO;
573}
574
575static void digital_in_recv_attrib_res(struct nfc_digital_dev *ddev, void *arg,
576 struct sk_buff *resp)
577{
578 struct nfc_target *target = arg;
579 struct digital_attrib_res *attrib_res;
580 int rc;
581
582 if (IS_ERR(resp)) {
583 rc = PTR_ERR(resp);
584 resp = NULL;
585 goto exit;
586 }
587
588 if (resp->len < sizeof(*attrib_res)) {
589 PROTOCOL_ERR("12.6.2");
590 rc = -EIO;
591 goto exit;
592 }
593
594 attrib_res = (struct digital_attrib_res *)resp->data;
595
596 if (attrib_res->mbli_did & 0x0f) {
597 PROTOCOL_ERR("12.6.2.1");
598 rc = -EIO;
599 goto exit;
600 }
601
602 rc = digital_target_found(ddev, target, NFC_PROTO_ISO14443_B);
603
604exit:
605 dev_kfree_skb(resp);
606 kfree(target);
607
608 if (rc)
609 digital_poll_next_tech(ddev);
610}
611
612static int digital_in_send_attrib_req(struct nfc_digital_dev *ddev,
613 struct nfc_target *target,
614 struct digital_sensb_res *sensb_res)
615{
616 struct digital_attrib_req *attrib_req;
617 struct sk_buff *skb;
618 int rc;
619
620 skb = digital_skb_alloc(ddev, sizeof(*attrib_req));
621 if (!skb)
622 return -ENOMEM;
623
624 attrib_req = skb_put(skb, sizeof(*attrib_req));
625
626 attrib_req->cmd = DIGITAL_CMD_ATTRIB_REQ;
627 memcpy(attrib_req->nfcid0, sensb_res->nfcid0,
628 sizeof(attrib_req->nfcid0));
629 attrib_req->param1 = DIGITAL_ATTRIB_P1_TR0_DEFAULT |
630 DIGITAL_ATTRIB_P1_TR1_DEFAULT;
631 attrib_req->param2 = DIGITAL_ATTRIB_P2_LISTEN_POLL_1 |
632 DIGITAL_ATTRIB_P2_POLL_LISTEN_1 |
633 DIGITAL_ATTRIB_P2_MAX_FRAME_256;
634 attrib_req->param3 = sensb_res->proto_info[1] & 0x07;
635 attrib_req->param4 = DIGITAL_ATTRIB_P4_DID(0);
636
637 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_attrib_res,
638 target);
639 if (rc)
640 kfree_skb(skb);
641
642 return rc;
643}
644
645static void digital_in_recv_sensb_res(struct nfc_digital_dev *ddev, void *arg,
646 struct sk_buff *resp)
647{
648 struct nfc_target *target = NULL;
649 struct digital_sensb_res *sensb_res;
650 u8 fsci;
651 int rc;
652
653 if (IS_ERR(resp)) {
654 rc = PTR_ERR(resp);
655 resp = NULL;
656 goto exit;
657 }
658
659 if (resp->len != sizeof(*sensb_res)) {
660 PROTOCOL_ERR("5.6.2.1");
661 rc = -EIO;
662 goto exit;
663 }
664
665 sensb_res = (struct digital_sensb_res *)resp->data;
666
667 if (sensb_res->cmd != DIGITAL_CMD_SENSB_RES) {
668 PROTOCOL_ERR("5.6.2");
669 rc = -EIO;
670 goto exit;
671 }
672
673 if (!(sensb_res->proto_info[1] & BIT(0))) {
674 PROTOCOL_ERR("5.6.2.12");
675 rc = -EIO;
676 goto exit;
677 }
678
679 if (sensb_res->proto_info[1] & BIT(3)) {
680 PROTOCOL_ERR("5.6.2.16");
681 rc = -EIO;
682 goto exit;
683 }
684
685 fsci = DIGITAL_SENSB_FSCI(sensb_res->proto_info[1]);
686 if (fsci >= 8)
687 ddev->target_fsc = DIGITAL_ATS_MAX_FSC;
688 else
689 ddev->target_fsc = digital_ats_fsc[fsci];
690
691 target = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
692 if (!target) {
693 rc = -ENOMEM;
694 goto exit;
695 }
696
697 rc = digital_in_send_attrib_req(ddev, target, sensb_res);
698
699exit:
700 dev_kfree_skb(resp);
701
702 if (rc) {
703 kfree(target);
704 digital_poll_next_tech(ddev);
705 }
706}
707
708int digital_in_send_sensb_req(struct nfc_digital_dev *ddev, u8 rf_tech)
709{
710 struct digital_sensb_req *sensb_req;
711 struct sk_buff *skb;
712 int rc;
713
714 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
715 NFC_DIGITAL_RF_TECH_106B);
716 if (rc)
717 return rc;
718
719 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
720 NFC_DIGITAL_FRAMING_NFCB);
721 if (rc)
722 return rc;
723
724 skb = digital_skb_alloc(ddev, sizeof(*sensb_req));
725 if (!skb)
726 return -ENOMEM;
727
728 sensb_req = skb_put(skb, sizeof(*sensb_req));
729
730 sensb_req->cmd = DIGITAL_CMD_SENSB_REQ;
731 sensb_req->afi = 0x00; /* All families and sub-families */
732 sensb_req->param = DIGITAL_SENSB_N(0);
733
734 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sensb_res,
735 NULL);
736 if (rc)
737 kfree_skb(skb);
738
739 return rc;
740}
741
742static void digital_in_recv_sensf_res(struct nfc_digital_dev *ddev, void *arg,
743 struct sk_buff *resp)
744{
745 int rc;
746 u8 proto;
747 struct nfc_target target;
748 struct digital_sensf_res *sensf_res;
749
750 if (IS_ERR(resp)) {
751 rc = PTR_ERR(resp);
752 resp = NULL;
753 goto exit;
754 }
755
756 if (resp->len < DIGITAL_SENSF_RES_MIN_LENGTH) {
757 rc = -EIO;
758 goto exit;
759 }
760
761 if (!DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
762 rc = digital_skb_check_crc_f(resp);
763 if (rc) {
764 PROTOCOL_ERR("6.4.1.8");
765 goto exit;
766 }
767 }
768
769 skb_pull(resp, 1);
770
771 memset(&target, 0, sizeof(struct nfc_target));
772
773 sensf_res = (struct digital_sensf_res *)resp->data;
774
775 memcpy(target.sensf_res, sensf_res, resp->len);
776 target.sensf_res_len = resp->len;
777
778 memcpy(target.nfcid2, sensf_res->nfcid2, NFC_NFCID2_MAXSIZE);
779 target.nfcid2_len = NFC_NFCID2_MAXSIZE;
780
781 if (target.nfcid2[0] == DIGITAL_SENSF_NFCID2_NFC_DEP_B1 &&
782 target.nfcid2[1] == DIGITAL_SENSF_NFCID2_NFC_DEP_B2)
783 proto = NFC_PROTO_NFC_DEP;
784 else
785 proto = NFC_PROTO_FELICA;
786
787 rc = digital_target_found(ddev, &target, proto);
788
789exit:
790 dev_kfree_skb(resp);
791
792 if (rc)
793 digital_poll_next_tech(ddev);
794}
795
796int digital_in_send_sensf_req(struct nfc_digital_dev *ddev, u8 rf_tech)
797{
798 struct digital_sensf_req *sensf_req;
799 struct sk_buff *skb;
800 int rc;
801 u8 size;
802
803 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
804 if (rc)
805 return rc;
806
807 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
808 NFC_DIGITAL_FRAMING_NFCF);
809 if (rc)
810 return rc;
811
812 size = sizeof(struct digital_sensf_req);
813
814 skb = digital_skb_alloc(ddev, size);
815 if (!skb)
816 return -ENOMEM;
817
818 skb_put(skb, size);
819
820 sensf_req = (struct digital_sensf_req *)skb->data;
821 sensf_req->cmd = DIGITAL_CMD_SENSF_REQ;
822 sensf_req->sc1 = 0xFF;
823 sensf_req->sc2 = 0xFF;
824 sensf_req->rc = 0;
825 sensf_req->tsn = 0;
826
827 *(u8 *)skb_push(skb, 1) = size + 1;
828
829 if (!DIGITAL_DRV_CAPS_IN_CRC(ddev))
830 digital_skb_add_crc_f(skb);
831
832 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sensf_res,
833 NULL);
834 if (rc)
835 kfree_skb(skb);
836
837 return rc;
838}
839
840static void digital_in_recv_iso15693_inv_res(struct nfc_digital_dev *ddev,
841 void *arg, struct sk_buff *resp)
842{
843 struct digital_iso15693_inv_res *res;
844 struct nfc_target *target = NULL;
845 int rc;
846
847 if (IS_ERR(resp)) {
848 rc = PTR_ERR(resp);
849 resp = NULL;
850 goto out_free_skb;
851 }
852
853 if (resp->len != sizeof(*res)) {
854 rc = -EIO;
855 goto out_free_skb;
856 }
857
858 res = (struct digital_iso15693_inv_res *)resp->data;
859
860 if (!DIGITAL_ISO15693_RES_IS_VALID(res->flags)) {
861 PROTOCOL_ERR("ISO15693 - 10.3.1");
862 rc = -EINVAL;
863 goto out_free_skb;
864 }
865
866 target = kzalloc(sizeof(*target), GFP_KERNEL);
867 if (!target) {
868 rc = -ENOMEM;
869 goto out_free_skb;
870 }
871
872 target->is_iso15693 = 1;
873 target->iso15693_dsfid = res->dsfid;
874 memcpy(target->iso15693_uid, &res->uid, sizeof(target->iso15693_uid));
875
876 rc = digital_target_found(ddev, target, NFC_PROTO_ISO15693);
877
878 kfree(target);
879
880out_free_skb:
881 dev_kfree_skb(resp);
882
883 if (rc)
884 digital_poll_next_tech(ddev);
885}
886
887int digital_in_send_iso15693_inv_req(struct nfc_digital_dev *ddev, u8 rf_tech)
888{
889 struct digital_iso15693_inv_req *req;
890 struct sk_buff *skb;
891 int rc;
892
893 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
894 NFC_DIGITAL_RF_TECH_ISO15693);
895 if (rc)
896 return rc;
897
898 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
899 NFC_DIGITAL_FRAMING_ISO15693_INVENTORY);
900 if (rc)
901 return rc;
902
903 skb = digital_skb_alloc(ddev, sizeof(*req));
904 if (!skb)
905 return -ENOMEM;
906
907 skb_put(skb, sizeof(*req) - sizeof(req->mask)); /* No mask */
908 req = (struct digital_iso15693_inv_req *)skb->data;
909
910 /* Single sub-carrier, high data rate, no AFI, single slot
911 * Inventory command
912 */
913 req->flags = DIGITAL_ISO15693_REQ_FLAG_DATA_RATE |
914 DIGITAL_ISO15693_REQ_FLAG_INVENTORY |
915 DIGITAL_ISO15693_REQ_FLAG_NB_SLOTS;
916 req->cmd = DIGITAL_CMD_ISO15693_INVENTORY_REQ;
917 req->mask_len = 0;
918
919 rc = digital_in_send_cmd(ddev, skb, 30,
920 digital_in_recv_iso15693_inv_res, NULL);
921 if (rc)
922 kfree_skb(skb);
923
924 return rc;
925}
926
927static int digital_tg_send_sel_res(struct nfc_digital_dev *ddev)
928{
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_put_u8(skb, DIGITAL_SEL_RES_NFC_DEP);
937
938 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev))
939 digital_skb_add_crc_a(skb);
940
941 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
942 NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE);
943 if (rc) {
944 kfree_skb(skb);
945 return rc;
946 }
947
948 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_atr_req,
949 NULL);
950 if (rc)
951 kfree_skb(skb);
952
953 return rc;
954}
955
956static void digital_tg_recv_sel_req(struct nfc_digital_dev *ddev, void *arg,
957 struct sk_buff *resp)
958{
959 int rc;
960
961 if (IS_ERR(resp)) {
962 rc = PTR_ERR(resp);
963 resp = NULL;
964 goto exit;
965 }
966
967 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
968 rc = digital_skb_check_crc_a(resp);
969 if (rc) {
970 PROTOCOL_ERR("4.4.1.3");
971 goto exit;
972 }
973 }
974
975 /* Silently ignore SEL_REQ content and send a SEL_RES for NFC-DEP */
976
977 rc = digital_tg_send_sel_res(ddev);
978
979exit:
980 if (rc)
981 digital_poll_next_tech(ddev);
982
983 dev_kfree_skb(resp);
984}
985
986static int digital_tg_send_sdd_res(struct nfc_digital_dev *ddev)
987{
988 struct sk_buff *skb;
989 struct digital_sdd_res *sdd_res;
990 int rc, i;
991
992 skb = digital_skb_alloc(ddev, sizeof(struct digital_sdd_res));
993 if (!skb)
994 return -ENOMEM;
995
996 skb_put(skb, sizeof(struct digital_sdd_res));
997 sdd_res = (struct digital_sdd_res *)skb->data;
998
999 sdd_res->nfcid1[0] = 0x08;
1000 get_random_bytes(sdd_res->nfcid1 + 1, 3);
1001
1002 sdd_res->bcc = 0;
1003 for (i = 0; i < 4; i++)
1004 sdd_res->bcc ^= sdd_res->nfcid1[i];
1005
1006 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1007 NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A);
1008 if (rc) {
1009 kfree_skb(skb);
1010 return rc;
1011 }
1012
1013 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sel_req,
1014 NULL);
1015 if (rc)
1016 kfree_skb(skb);
1017
1018 return rc;
1019}
1020
1021static void digital_tg_recv_sdd_req(struct nfc_digital_dev *ddev, void *arg,
1022 struct sk_buff *resp)
1023{
1024 u8 *sdd_req;
1025 int rc;
1026
1027 if (IS_ERR(resp)) {
1028 rc = PTR_ERR(resp);
1029 resp = NULL;
1030 goto exit;
1031 }
1032
1033 sdd_req = resp->data;
1034
1035 if (resp->len < 2 || sdd_req[0] != DIGITAL_CMD_SEL_REQ_CL1 ||
1036 sdd_req[1] != DIGITAL_SDD_REQ_SEL_PAR) {
1037 rc = -EINVAL;
1038 goto exit;
1039 }
1040
1041 rc = digital_tg_send_sdd_res(ddev);
1042
1043exit:
1044 if (rc)
1045 digital_poll_next_tech(ddev);
1046
1047 dev_kfree_skb(resp);
1048}
1049
1050static int digital_tg_send_sens_res(struct nfc_digital_dev *ddev)
1051{
1052 struct sk_buff *skb;
1053 u8 *sens_res;
1054 int rc;
1055
1056 skb = digital_skb_alloc(ddev, 2);
1057 if (!skb)
1058 return -ENOMEM;
1059
1060 sens_res = skb_put(skb, 2);
1061
1062 sens_res[0] = (DIGITAL_SENS_RES_NFC_DEP >> 8) & 0xFF;
1063 sens_res[1] = DIGITAL_SENS_RES_NFC_DEP & 0xFF;
1064
1065 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1066 NFC_DIGITAL_FRAMING_NFCA_STANDARD);
1067 if (rc) {
1068 kfree_skb(skb);
1069 return rc;
1070 }
1071
1072 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sdd_req,
1073 NULL);
1074 if (rc)
1075 kfree_skb(skb);
1076
1077 return rc;
1078}
1079
1080void digital_tg_recv_sens_req(struct nfc_digital_dev *ddev, void *arg,
1081 struct sk_buff *resp)
1082{
1083 u8 sens_req;
1084 int rc;
1085
1086 if (IS_ERR(resp)) {
1087 rc = PTR_ERR(resp);
1088 resp = NULL;
1089 goto exit;
1090 }
1091
1092 sens_req = resp->data[0];
1093
1094 if (!resp->len || (sens_req != DIGITAL_CMD_SENS_REQ &&
1095 sens_req != DIGITAL_CMD_ALL_REQ)) {
1096 rc = -EINVAL;
1097 goto exit;
1098 }
1099
1100 rc = digital_tg_send_sens_res(ddev);
1101
1102exit:
1103 if (rc)
1104 digital_poll_next_tech(ddev);
1105
1106 dev_kfree_skb(resp);
1107}
1108
1109static void digital_tg_recv_atr_or_sensf_req(struct nfc_digital_dev *ddev,
1110 void *arg, struct sk_buff *resp)
1111{
1112 if (!IS_ERR(resp) && (resp->len >= 2) &&
1113 (resp->data[1] == DIGITAL_CMD_SENSF_REQ))
1114 digital_tg_recv_sensf_req(ddev, arg, resp);
1115 else
1116 digital_tg_recv_atr_req(ddev, arg, resp);
1117
1118 return;
1119}
1120
1121static int digital_tg_send_sensf_res(struct nfc_digital_dev *ddev,
1122 struct digital_sensf_req *sensf_req)
1123{
1124 struct sk_buff *skb;
1125 u8 size;
1126 int rc;
1127 struct digital_sensf_res *sensf_res;
1128
1129 size = sizeof(struct digital_sensf_res);
1130
1131 if (sensf_req->rc == DIGITAL_SENSF_REQ_RC_NONE)
1132 size -= sizeof(sensf_res->rd);
1133
1134 skb = digital_skb_alloc(ddev, size);
1135 if (!skb)
1136 return -ENOMEM;
1137
1138 skb_put(skb, size);
1139
1140 sensf_res = (struct digital_sensf_res *)skb->data;
1141
1142 memset(sensf_res, 0, size);
1143
1144 sensf_res->cmd = DIGITAL_CMD_SENSF_RES;
1145 sensf_res->nfcid2[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1;
1146 sensf_res->nfcid2[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2;
1147 get_random_bytes(&sensf_res->nfcid2[2], 6);
1148
1149 switch (sensf_req->rc) {
1150 case DIGITAL_SENSF_REQ_RC_SC:
1151 sensf_res->rd[0] = sensf_req->sc1;
1152 sensf_res->rd[1] = sensf_req->sc2;
1153 break;
1154 case DIGITAL_SENSF_REQ_RC_AP:
1155 sensf_res->rd[0] = DIGITAL_SENSF_RES_RD_AP_B1;
1156 sensf_res->rd[1] = DIGITAL_SENSF_RES_RD_AP_B2;
1157 break;
1158 }
1159
1160 *(u8 *)skb_push(skb, sizeof(u8)) = size + 1;
1161
1162 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev))
1163 digital_skb_add_crc_f(skb);
1164
1165 rc = digital_tg_send_cmd(ddev, skb, 300,
1166 digital_tg_recv_atr_or_sensf_req, NULL);
1167 if (rc)
1168 kfree_skb(skb);
1169
1170 return rc;
1171}
1172
1173void digital_tg_recv_sensf_req(struct nfc_digital_dev *ddev, void *arg,
1174 struct sk_buff *resp)
1175{
1176 struct digital_sensf_req *sensf_req;
1177 int rc;
1178
1179 if (IS_ERR(resp)) {
1180 rc = PTR_ERR(resp);
1181 resp = NULL;
1182 goto exit;
1183 }
1184
1185 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
1186 rc = digital_skb_check_crc_f(resp);
1187 if (rc) {
1188 PROTOCOL_ERR("6.4.1.8");
1189 goto exit;
1190 }
1191 }
1192
1193 if (resp->len != sizeof(struct digital_sensf_req) + 1) {
1194 rc = -EINVAL;
1195 goto exit;
1196 }
1197
1198 skb_pull(resp, 1);
1199 sensf_req = (struct digital_sensf_req *)resp->data;
1200
1201 if (sensf_req->cmd != DIGITAL_CMD_SENSF_REQ) {
1202 rc = -EINVAL;
1203 goto exit;
1204 }
1205
1206 rc = digital_tg_send_sensf_res(ddev, sensf_req);
1207
1208exit:
1209 if (rc)
1210 digital_poll_next_tech(ddev);
1211
1212 dev_kfree_skb(resp);
1213}
1214
1215static int digital_tg_config_nfca(struct nfc_digital_dev *ddev)
1216{
1217 int rc;
1218
1219 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
1220 NFC_DIGITAL_RF_TECH_106A);
1221 if (rc)
1222 return rc;
1223
1224 return digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1225 NFC_DIGITAL_FRAMING_NFCA_NFC_DEP);
1226}
1227
1228int digital_tg_listen_nfca(struct nfc_digital_dev *ddev, u8 rf_tech)
1229{
1230 int rc;
1231
1232 rc = digital_tg_config_nfca(ddev);
1233 if (rc)
1234 return rc;
1235
1236 return digital_tg_listen(ddev, 300, digital_tg_recv_sens_req, NULL);
1237}
1238
1239static int digital_tg_config_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech)
1240{
1241 int rc;
1242
1243 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
1244 if (rc)
1245 return rc;
1246
1247 return digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1248 NFC_DIGITAL_FRAMING_NFCF_NFC_DEP);
1249}
1250
1251int digital_tg_listen_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech)
1252{
1253 int rc;
1254
1255 rc = digital_tg_config_nfcf(ddev, rf_tech);
1256 if (rc)
1257 return rc;
1258
1259 return digital_tg_listen(ddev, 300, digital_tg_recv_sensf_req, NULL);
1260}
1261
1262void digital_tg_recv_md_req(struct nfc_digital_dev *ddev, void *arg,
1263 struct sk_buff *resp)
1264{
1265 u8 rf_tech;
1266 int rc;
1267
1268 if (IS_ERR(resp)) {
1269 resp = NULL;
1270 goto exit_free_skb;
1271 }
1272
1273 rc = ddev->ops->tg_get_rf_tech(ddev, &rf_tech);
1274 if (rc)
1275 goto exit_free_skb;
1276
1277 switch (rf_tech) {
1278 case NFC_DIGITAL_RF_TECH_106A:
1279 rc = digital_tg_config_nfca(ddev);
1280 if (rc)
1281 goto exit_free_skb;
1282 digital_tg_recv_sens_req(ddev, arg, resp);
1283 break;
1284 case NFC_DIGITAL_RF_TECH_212F:
1285 case NFC_DIGITAL_RF_TECH_424F:
1286 rc = digital_tg_config_nfcf(ddev, rf_tech);
1287 if (rc)
1288 goto exit_free_skb;
1289 digital_tg_recv_sensf_req(ddev, arg, resp);
1290 break;
1291 default:
1292 goto exit_free_skb;
1293 }
1294
1295 return;
1296
1297exit_free_skb:
1298 digital_poll_next_tech(ddev);
1299 dev_kfree_skb(resp);
1300}