projects/linux·blob master · refs

1308 lines · 26.6 KiB

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 if (target->nfcid1_len + size > NFC_NFCID1_MAXSIZE) {
428 PROTOCOL_ERR("4.7.2.1");
429 rc = -EPROTO;
430 goto exit;
431 }
432
433 memcpy(target->nfcid1 + target->nfcid1_len, sdd_res->nfcid1 + offset,
434 size);
435 target->nfcid1_len += size;
436
437 rc = digital_in_send_sel_req(ddev, target, sdd_res);
438
439exit:
440 dev_kfree_skb(resp);
441
442 if (rc) {
443 kfree(target);
444 digital_poll_next_tech(ddev);
445 }
446}
447
448static int digital_in_send_sdd_req(struct nfc_digital_dev *ddev,
449 struct nfc_target *target)
450{
451 int rc;
452 struct sk_buff *skb;
453 u8 sel_cmd;
454
455 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
456 NFC_DIGITAL_FRAMING_NFCA_STANDARD);
457 if (rc)
458 return rc;
459
460 skb = digital_skb_alloc(ddev, 2);
461 if (!skb)
462 return -ENOMEM;
463
464 if (target->nfcid1_len == 0)
465 sel_cmd = DIGITAL_CMD_SEL_REQ_CL1;
466 else if (target->nfcid1_len == 3)
467 sel_cmd = DIGITAL_CMD_SEL_REQ_CL2;
468 else
469 sel_cmd = DIGITAL_CMD_SEL_REQ_CL3;
470
471 skb_put_u8(skb, sel_cmd);
472 skb_put_u8(skb, DIGITAL_SDD_REQ_SEL_PAR);
473
474 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sdd_res,
475 target);
476 if (rc)
477 kfree_skb(skb);
478
479 return rc;
480}
481
482static void digital_in_recv_sens_res(struct nfc_digital_dev *ddev, void *arg,
483 struct sk_buff *resp)
484{
485 struct nfc_target *target = NULL;
486 int rc;
487
488 if (IS_ERR(resp)) {
489 rc = PTR_ERR(resp);
490 resp = NULL;
491 goto exit;
492 }
493
494 if (resp->len < sizeof(u16)) {
495 rc = -EIO;
496 goto exit;
497 }
498
499 target = kzalloc_obj(struct nfc_target);
500 if (!target) {
501 rc = -ENOMEM;
502 goto exit;
503 }
504
505 target->sens_res = __le16_to_cpu(*(__le16 *)resp->data);
506
507 if (!DIGITAL_SENS_RES_IS_VALID(target->sens_res)) {
508 PROTOCOL_ERR("4.6.3.3");
509 rc = -EINVAL;
510 goto exit;
511 }
512
513 if (DIGITAL_SENS_RES_IS_T1T(target->sens_res))
514 rc = digital_target_found(ddev, target, NFC_PROTO_JEWEL);
515 else
516 rc = digital_in_send_sdd_req(ddev, target);
517
518exit:
519 dev_kfree_skb(resp);
520
521 if (rc) {
522 kfree(target);
523 digital_poll_next_tech(ddev);
524 }
525}
526
527int digital_in_send_sens_req(struct nfc_digital_dev *ddev, u8 rf_tech)
528{
529 struct sk_buff *skb;
530 int rc;
531
532 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
533 NFC_DIGITAL_RF_TECH_106A);
534 if (rc)
535 return rc;
536
537 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
538 NFC_DIGITAL_FRAMING_NFCA_SHORT);
539 if (rc)
540 return rc;
541
542 skb = digital_skb_alloc(ddev, 1);
543 if (!skb)
544 return -ENOMEM;
545
546 skb_put_u8(skb, DIGITAL_CMD_SENS_REQ);
547
548 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sens_res, NULL);
549 if (rc)
550 kfree_skb(skb);
551
552 return rc;
553}
554
555int digital_in_recv_mifare_res(struct sk_buff *resp)
556{
557 /* Successful READ command response is 16 data bytes + 2 CRC bytes long.
558 * Since the driver can't differentiate a ACK/NACK response from a valid
559 * READ response, the CRC calculation must be handled at digital level
560 * even if the driver supports it for this technology.
561 */
562 if (resp->len == DIGITAL_MIFARE_READ_RES_LEN + DIGITAL_CRC_LEN) {
563 if (digital_skb_check_crc_a(resp)) {
564 PROTOCOL_ERR("9.4.1.2");
565 return -EIO;
566 }
567
568 return 0;
569 }
570
571 /* ACK response (i.e. successful WRITE). */
572 if (resp->len == 1 && resp->data[0] == DIGITAL_MIFARE_ACK_RES) {
573 resp->data[0] = 0;
574 return 0;
575 }
576
577 /* NACK and any other responses are treated as error. */
578 return -EIO;
579}
580
581static void digital_in_recv_attrib_res(struct nfc_digital_dev *ddev, void *arg,
582 struct sk_buff *resp)
583{
584 struct nfc_target *target = arg;
585 struct digital_attrib_res *attrib_res;
586 int rc;
587
588 if (IS_ERR(resp)) {
589 rc = PTR_ERR(resp);
590 resp = NULL;
591 goto exit;
592 }
593
594 if (resp->len < sizeof(*attrib_res)) {
595 PROTOCOL_ERR("12.6.2");
596 rc = -EIO;
597 goto exit;
598 }
599
600 attrib_res = (struct digital_attrib_res *)resp->data;
601
602 if (attrib_res->mbli_did & 0x0f) {
603 PROTOCOL_ERR("12.6.2.1");
604 rc = -EIO;
605 goto exit;
606 }
607
608 rc = digital_target_found(ddev, target, NFC_PROTO_ISO14443_B);
609
610exit:
611 dev_kfree_skb(resp);
612 kfree(target);
613
614 if (rc)
615 digital_poll_next_tech(ddev);
616}
617
618static int digital_in_send_attrib_req(struct nfc_digital_dev *ddev,
619 struct nfc_target *target,
620 struct digital_sensb_res *sensb_res)
621{
622 struct digital_attrib_req *attrib_req;
623 struct sk_buff *skb;
624 int rc;
625
626 skb = digital_skb_alloc(ddev, sizeof(*attrib_req));
627 if (!skb)
628 return -ENOMEM;
629
630 attrib_req = skb_put(skb, sizeof(*attrib_req));
631
632 attrib_req->cmd = DIGITAL_CMD_ATTRIB_REQ;
633 memcpy(attrib_req->nfcid0, sensb_res->nfcid0,
634 sizeof(attrib_req->nfcid0));
635 attrib_req->param1 = DIGITAL_ATTRIB_P1_TR0_DEFAULT |
636 DIGITAL_ATTRIB_P1_TR1_DEFAULT;
637 attrib_req->param2 = DIGITAL_ATTRIB_P2_LISTEN_POLL_1 |
638 DIGITAL_ATTRIB_P2_POLL_LISTEN_1 |
639 DIGITAL_ATTRIB_P2_MAX_FRAME_256;
640 attrib_req->param3 = sensb_res->proto_info[1] & 0x07;
641 attrib_req->param4 = DIGITAL_ATTRIB_P4_DID(0);
642
643 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_attrib_res,
644 target);
645 if (rc)
646 kfree_skb(skb);
647
648 return rc;
649}
650
651static void digital_in_recv_sensb_res(struct nfc_digital_dev *ddev, void *arg,
652 struct sk_buff *resp)
653{
654 struct nfc_target *target = NULL;
655 struct digital_sensb_res *sensb_res;
656 u8 fsci;
657 int rc;
658
659 if (IS_ERR(resp)) {
660 rc = PTR_ERR(resp);
661 resp = NULL;
662 goto exit;
663 }
664
665 if (resp->len != sizeof(*sensb_res)) {
666 PROTOCOL_ERR("5.6.2.1");
667 rc = -EIO;
668 goto exit;
669 }
670
671 sensb_res = (struct digital_sensb_res *)resp->data;
672
673 if (sensb_res->cmd != DIGITAL_CMD_SENSB_RES) {
674 PROTOCOL_ERR("5.6.2");
675 rc = -EIO;
676 goto exit;
677 }
678
679 if (!(sensb_res->proto_info[1] & BIT(0))) {
680 PROTOCOL_ERR("5.6.2.12");
681 rc = -EIO;
682 goto exit;
683 }
684
685 if (sensb_res->proto_info[1] & BIT(3)) {
686 PROTOCOL_ERR("5.6.2.16");
687 rc = -EIO;
688 goto exit;
689 }
690
691 fsci = DIGITAL_SENSB_FSCI(sensb_res->proto_info[1]);
692 if (fsci >= 8)
693 ddev->target_fsc = DIGITAL_ATS_MAX_FSC;
694 else
695 ddev->target_fsc = digital_ats_fsc[fsci];
696
697 target = kzalloc_obj(struct nfc_target);
698 if (!target) {
699 rc = -ENOMEM;
700 goto exit;
701 }
702
703 rc = digital_in_send_attrib_req(ddev, target, sensb_res);
704
705exit:
706 dev_kfree_skb(resp);
707
708 if (rc) {
709 kfree(target);
710 digital_poll_next_tech(ddev);
711 }
712}
713
714int digital_in_send_sensb_req(struct nfc_digital_dev *ddev, u8 rf_tech)
715{
716 struct digital_sensb_req *sensb_req;
717 struct sk_buff *skb;
718 int rc;
719
720 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
721 NFC_DIGITAL_RF_TECH_106B);
722 if (rc)
723 return rc;
724
725 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
726 NFC_DIGITAL_FRAMING_NFCB);
727 if (rc)
728 return rc;
729
730 skb = digital_skb_alloc(ddev, sizeof(*sensb_req));
731 if (!skb)
732 return -ENOMEM;
733
734 sensb_req = skb_put(skb, sizeof(*sensb_req));
735
736 sensb_req->cmd = DIGITAL_CMD_SENSB_REQ;
737 sensb_req->afi = 0x00; /* All families and sub-families */
738 sensb_req->param = DIGITAL_SENSB_N(0);
739
740 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sensb_res,
741 NULL);
742 if (rc)
743 kfree_skb(skb);
744
745 return rc;
746}
747
748static void digital_in_recv_sensf_res(struct nfc_digital_dev *ddev, void *arg,
749 struct sk_buff *resp)
750{
751 int rc;
752 u8 proto;
753 struct nfc_target target;
754 struct digital_sensf_res *sensf_res;
755
756 if (IS_ERR(resp)) {
757 rc = PTR_ERR(resp);
758 resp = NULL;
759 goto exit;
760 }
761
762 if (resp->len < DIGITAL_SENSF_RES_MIN_LENGTH) {
763 rc = -EIO;
764 goto exit;
765 }
766
767 if (!DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
768 rc = digital_skb_check_crc_f(resp);
769 if (rc) {
770 PROTOCOL_ERR("6.4.1.8");
771 goto exit;
772 }
773 }
774
775 skb_pull(resp, 1);
776
777 memset(&target, 0, sizeof(struct nfc_target));
778
779 sensf_res = (struct digital_sensf_res *)resp->data;
780
781 resp->len = min_t(unsigned int, resp->len, NFC_SENSF_RES_MAXSIZE);
782
783 memcpy(target.sensf_res, sensf_res, resp->len);
784 target.sensf_res_len = resp->len;
785
786 memcpy(target.nfcid2, sensf_res->nfcid2, NFC_NFCID2_MAXSIZE);
787 target.nfcid2_len = NFC_NFCID2_MAXSIZE;
788
789 if (target.nfcid2[0] == DIGITAL_SENSF_NFCID2_NFC_DEP_B1 &&
790 target.nfcid2[1] == DIGITAL_SENSF_NFCID2_NFC_DEP_B2)
791 proto = NFC_PROTO_NFC_DEP;
792 else
793 proto = NFC_PROTO_FELICA;
794
795 rc = digital_target_found(ddev, &target, proto);
796
797exit:
798 dev_kfree_skb(resp);
799
800 if (rc)
801 digital_poll_next_tech(ddev);
802}
803
804int digital_in_send_sensf_req(struct nfc_digital_dev *ddev, u8 rf_tech)
805{
806 struct digital_sensf_req *sensf_req;
807 struct sk_buff *skb;
808 int rc;
809 u8 size;
810
811 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
812 if (rc)
813 return rc;
814
815 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
816 NFC_DIGITAL_FRAMING_NFCF);
817 if (rc)
818 return rc;
819
820 size = sizeof(struct digital_sensf_req);
821
822 skb = digital_skb_alloc(ddev, size);
823 if (!skb)
824 return -ENOMEM;
825
826 skb_put(skb, size);
827
828 sensf_req = (struct digital_sensf_req *)skb->data;
829 sensf_req->cmd = DIGITAL_CMD_SENSF_REQ;
830 sensf_req->sc1 = 0xFF;
831 sensf_req->sc2 = 0xFF;
832 sensf_req->rc = 0;
833 sensf_req->tsn = 0;
834
835 *(u8 *)skb_push(skb, 1) = size + 1;
836
837 if (!DIGITAL_DRV_CAPS_IN_CRC(ddev))
838 digital_skb_add_crc_f(skb);
839
840 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sensf_res,
841 NULL);
842 if (rc)
843 kfree_skb(skb);
844
845 return rc;
846}
847
848static void digital_in_recv_iso15693_inv_res(struct nfc_digital_dev *ddev,
849 void *arg, struct sk_buff *resp)
850{
851 struct digital_iso15693_inv_res *res;
852 struct nfc_target *target = NULL;
853 int rc;
854
855 if (IS_ERR(resp)) {
856 rc = PTR_ERR(resp);
857 resp = NULL;
858 goto out_free_skb;
859 }
860
861 if (resp->len != sizeof(*res)) {
862 rc = -EIO;
863 goto out_free_skb;
864 }
865
866 res = (struct digital_iso15693_inv_res *)resp->data;
867
868 if (!DIGITAL_ISO15693_RES_IS_VALID(res->flags)) {
869 PROTOCOL_ERR("ISO15693 - 10.3.1");
870 rc = -EINVAL;
871 goto out_free_skb;
872 }
873
874 target = kzalloc_obj(*target);
875 if (!target) {
876 rc = -ENOMEM;
877 goto out_free_skb;
878 }
879
880 target->is_iso15693 = 1;
881 target->iso15693_dsfid = res->dsfid;
882 memcpy(target->iso15693_uid, &res->uid, sizeof(target->iso15693_uid));
883
884 rc = digital_target_found(ddev, target, NFC_PROTO_ISO15693);
885
886 kfree(target);
887
888out_free_skb:
889 dev_kfree_skb(resp);
890
891 if (rc)
892 digital_poll_next_tech(ddev);
893}
894
895int digital_in_send_iso15693_inv_req(struct nfc_digital_dev *ddev, u8 rf_tech)
896{
897 struct digital_iso15693_inv_req *req;
898 struct sk_buff *skb;
899 int rc;
900
901 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
902 NFC_DIGITAL_RF_TECH_ISO15693);
903 if (rc)
904 return rc;
905
906 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
907 NFC_DIGITAL_FRAMING_ISO15693_INVENTORY);
908 if (rc)
909 return rc;
910
911 skb = digital_skb_alloc(ddev, sizeof(*req));
912 if (!skb)
913 return -ENOMEM;
914
915 skb_put(skb, sizeof(*req) - sizeof(req->mask)); /* No mask */
916 req = (struct digital_iso15693_inv_req *)skb->data;
917
918 /* Single sub-carrier, high data rate, no AFI, single slot
919 * Inventory command
920 */
921 req->flags = DIGITAL_ISO15693_REQ_FLAG_DATA_RATE |
922 DIGITAL_ISO15693_REQ_FLAG_INVENTORY |
923 DIGITAL_ISO15693_REQ_FLAG_NB_SLOTS;
924 req->cmd = DIGITAL_CMD_ISO15693_INVENTORY_REQ;
925 req->mask_len = 0;
926
927 rc = digital_in_send_cmd(ddev, skb, 30,
928 digital_in_recv_iso15693_inv_res, NULL);
929 if (rc)
930 kfree_skb(skb);
931
932 return rc;
933}
934
935static int digital_tg_send_sel_res(struct nfc_digital_dev *ddev)
936{
937 struct sk_buff *skb;
938 int rc;
939
940 skb = digital_skb_alloc(ddev, 1);
941 if (!skb)
942 return -ENOMEM;
943
944 skb_put_u8(skb, DIGITAL_SEL_RES_NFC_DEP);
945
946 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev))
947 digital_skb_add_crc_a(skb);
948
949 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
950 NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE);
951 if (rc) {
952 kfree_skb(skb);
953 return rc;
954 }
955
956 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_atr_req,
957 NULL);
958 if (rc)
959 kfree_skb(skb);
960
961 return rc;
962}
963
964static void digital_tg_recv_sel_req(struct nfc_digital_dev *ddev, void *arg,
965 struct sk_buff *resp)
966{
967 int rc;
968
969 if (IS_ERR(resp)) {
970 rc = PTR_ERR(resp);
971 resp = NULL;
972 goto exit;
973 }
974
975 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
976 rc = digital_skb_check_crc_a(resp);
977 if (rc) {
978 PROTOCOL_ERR("4.4.1.3");
979 goto exit;
980 }
981 }
982
983 /* Silently ignore SEL_REQ content and send a SEL_RES for NFC-DEP */
984
985 rc = digital_tg_send_sel_res(ddev);
986
987exit:
988 if (rc)
989 digital_poll_next_tech(ddev);
990
991 dev_kfree_skb(resp);
992}
993
994static int digital_tg_send_sdd_res(struct nfc_digital_dev *ddev)
995{
996 struct sk_buff *skb;
997 struct digital_sdd_res *sdd_res;
998 int rc, i;
999
1000 skb = digital_skb_alloc(ddev, sizeof(struct digital_sdd_res));
1001 if (!skb)
1002 return -ENOMEM;
1003
1004 skb_put(skb, sizeof(struct digital_sdd_res));
1005 sdd_res = (struct digital_sdd_res *)skb->data;
1006
1007 sdd_res->nfcid1[0] = 0x08;
1008 get_random_bytes(sdd_res->nfcid1 + 1, 3);
1009
1010 sdd_res->bcc = 0;
1011 for (i = 0; i < 4; i++)
1012 sdd_res->bcc ^= sdd_res->nfcid1[i];
1013
1014 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1015 NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A);
1016 if (rc) {
1017 kfree_skb(skb);
1018 return rc;
1019 }
1020
1021 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sel_req,
1022 NULL);
1023 if (rc)
1024 kfree_skb(skb);
1025
1026 return rc;
1027}
1028
1029static void digital_tg_recv_sdd_req(struct nfc_digital_dev *ddev, void *arg,
1030 struct sk_buff *resp)
1031{
1032 u8 *sdd_req;
1033 int rc;
1034
1035 if (IS_ERR(resp)) {
1036 rc = PTR_ERR(resp);
1037 resp = NULL;
1038 goto exit;
1039 }
1040
1041 sdd_req = resp->data;
1042
1043 if (resp->len < 2 || sdd_req[0] != DIGITAL_CMD_SEL_REQ_CL1 ||
1044 sdd_req[1] != DIGITAL_SDD_REQ_SEL_PAR) {
1045 rc = -EINVAL;
1046 goto exit;
1047 }
1048
1049 rc = digital_tg_send_sdd_res(ddev);
1050
1051exit:
1052 if (rc)
1053 digital_poll_next_tech(ddev);
1054
1055 dev_kfree_skb(resp);
1056}
1057
1058static int digital_tg_send_sens_res(struct nfc_digital_dev *ddev)
1059{
1060 struct sk_buff *skb;
1061 u8 *sens_res;
1062 int rc;
1063
1064 skb = digital_skb_alloc(ddev, 2);
1065 if (!skb)
1066 return -ENOMEM;
1067
1068 sens_res = skb_put(skb, 2);
1069
1070 sens_res[0] = (DIGITAL_SENS_RES_NFC_DEP >> 8) & 0xFF;
1071 sens_res[1] = DIGITAL_SENS_RES_NFC_DEP & 0xFF;
1072
1073 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1074 NFC_DIGITAL_FRAMING_NFCA_STANDARD);
1075 if (rc) {
1076 kfree_skb(skb);
1077 return rc;
1078 }
1079
1080 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sdd_req,
1081 NULL);
1082 if (rc)
1083 kfree_skb(skb);
1084
1085 return rc;
1086}
1087
1088void digital_tg_recv_sens_req(struct nfc_digital_dev *ddev, void *arg,
1089 struct sk_buff *resp)
1090{
1091 u8 sens_req;
1092 int rc;
1093
1094 if (IS_ERR(resp)) {
1095 rc = PTR_ERR(resp);
1096 resp = NULL;
1097 goto exit;
1098 }
1099
1100 sens_req = resp->data[0];
1101
1102 if (!resp->len || (sens_req != DIGITAL_CMD_SENS_REQ &&
1103 sens_req != DIGITAL_CMD_ALL_REQ)) {
1104 rc = -EINVAL;
1105 goto exit;
1106 }
1107
1108 rc = digital_tg_send_sens_res(ddev);
1109
1110exit:
1111 if (rc)
1112 digital_poll_next_tech(ddev);
1113
1114 dev_kfree_skb(resp);
1115}
1116
1117static void digital_tg_recv_atr_or_sensf_req(struct nfc_digital_dev *ddev,
1118 void *arg, struct sk_buff *resp)
1119{
1120 if (!IS_ERR(resp) && (resp->len >= 2) &&
1121 (resp->data[1] == DIGITAL_CMD_SENSF_REQ))
1122 digital_tg_recv_sensf_req(ddev, arg, resp);
1123 else
1124 digital_tg_recv_atr_req(ddev, arg, resp);
1125
1126 return;
1127}
1128
1129static int digital_tg_send_sensf_res(struct nfc_digital_dev *ddev,
1130 struct digital_sensf_req *sensf_req)
1131{
1132 struct sk_buff *skb;
1133 u8 size;
1134 int rc;
1135 struct digital_sensf_res *sensf_res;
1136
1137 size = sizeof(struct digital_sensf_res);
1138
1139 if (sensf_req->rc == DIGITAL_SENSF_REQ_RC_NONE)
1140 size -= sizeof(sensf_res->rd);
1141
1142 skb = digital_skb_alloc(ddev, size);
1143 if (!skb)
1144 return -ENOMEM;
1145
1146 skb_put(skb, size);
1147
1148 sensf_res = (struct digital_sensf_res *)skb->data;
1149
1150 memset(sensf_res, 0, size);
1151
1152 sensf_res->cmd = DIGITAL_CMD_SENSF_RES;
1153 sensf_res->nfcid2[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1;
1154 sensf_res->nfcid2[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2;
1155 get_random_bytes(&sensf_res->nfcid2[2], 6);
1156
1157 switch (sensf_req->rc) {
1158 case DIGITAL_SENSF_REQ_RC_SC:
1159 sensf_res->rd[0] = sensf_req->sc1;
1160 sensf_res->rd[1] = sensf_req->sc2;
1161 break;
1162 case DIGITAL_SENSF_REQ_RC_AP:
1163 sensf_res->rd[0] = DIGITAL_SENSF_RES_RD_AP_B1;
1164 sensf_res->rd[1] = DIGITAL_SENSF_RES_RD_AP_B2;
1165 break;
1166 }
1167
1168 *(u8 *)skb_push(skb, sizeof(u8)) = size + 1;
1169
1170 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev))
1171 digital_skb_add_crc_f(skb);
1172
1173 rc = digital_tg_send_cmd(ddev, skb, 300,
1174 digital_tg_recv_atr_or_sensf_req, NULL);
1175 if (rc)
1176 kfree_skb(skb);
1177
1178 return rc;
1179}
1180
1181void digital_tg_recv_sensf_req(struct nfc_digital_dev *ddev, void *arg,
1182 struct sk_buff *resp)
1183{
1184 struct digital_sensf_req *sensf_req;
1185 int rc;
1186
1187 if (IS_ERR(resp)) {
1188 rc = PTR_ERR(resp);
1189 resp = NULL;
1190 goto exit;
1191 }
1192
1193 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
1194 rc = digital_skb_check_crc_f(resp);
1195 if (rc) {
1196 PROTOCOL_ERR("6.4.1.8");
1197 goto exit;
1198 }
1199 }
1200
1201 if (resp->len != sizeof(struct digital_sensf_req) + 1) {
1202 rc = -EINVAL;
1203 goto exit;
1204 }
1205
1206 skb_pull(resp, 1);
1207 sensf_req = (struct digital_sensf_req *)resp->data;
1208
1209 if (sensf_req->cmd != DIGITAL_CMD_SENSF_REQ) {
1210 rc = -EINVAL;
1211 goto exit;
1212 }
1213
1214 rc = digital_tg_send_sensf_res(ddev, sensf_req);
1215
1216exit:
1217 if (rc)
1218 digital_poll_next_tech(ddev);
1219
1220 dev_kfree_skb(resp);
1221}
1222
1223static int digital_tg_config_nfca(struct nfc_digital_dev *ddev)
1224{
1225 int rc;
1226
1227 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
1228 NFC_DIGITAL_RF_TECH_106A);
1229 if (rc)
1230 return rc;
1231
1232 return digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1233 NFC_DIGITAL_FRAMING_NFCA_NFC_DEP);
1234}
1235
1236int digital_tg_listen_nfca(struct nfc_digital_dev *ddev, u8 rf_tech)
1237{
1238 int rc;
1239
1240 rc = digital_tg_config_nfca(ddev);
1241 if (rc)
1242 return rc;
1243
1244 return digital_tg_listen(ddev, 300, digital_tg_recv_sens_req, NULL);
1245}
1246
1247static int digital_tg_config_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech)
1248{
1249 int rc;
1250
1251 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
1252 if (rc)
1253 return rc;
1254
1255 return digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1256 NFC_DIGITAL_FRAMING_NFCF_NFC_DEP);
1257}
1258
1259int digital_tg_listen_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech)
1260{
1261 int rc;
1262
1263 rc = digital_tg_config_nfcf(ddev, rf_tech);
1264 if (rc)
1265 return rc;
1266
1267 return digital_tg_listen(ddev, 300, digital_tg_recv_sensf_req, NULL);
1268}
1269
1270void digital_tg_recv_md_req(struct nfc_digital_dev *ddev, void *arg,
1271 struct sk_buff *resp)
1272{
1273 u8 rf_tech;
1274 int rc;
1275
1276 if (IS_ERR(resp)) {
1277 resp = NULL;
1278 goto exit_free_skb;
1279 }
1280
1281 rc = ddev->ops->tg_get_rf_tech(ddev, &rf_tech);
1282 if (rc)
1283 goto exit_free_skb;
1284
1285 switch (rf_tech) {
1286 case NFC_DIGITAL_RF_TECH_106A:
1287 rc = digital_tg_config_nfca(ddev);
1288 if (rc)
1289 goto exit_free_skb;
1290 digital_tg_recv_sens_req(ddev, arg, resp);
1291 break;
1292 case NFC_DIGITAL_RF_TECH_212F:
1293 case NFC_DIGITAL_RF_TECH_424F:
1294 rc = digital_tg_config_nfcf(ddev, rf_tech);
1295 if (rc)
1296 goto exit_free_skb;
1297 digital_tg_recv_sensf_req(ddev, arg, resp);
1298 break;
1299 default:
1300 goto exit_free_skb;
1301 }
1302
1303 return;
1304
1305exit_free_skb:
1306 digital_poll_next_tech(ddev);
1307 dev_kfree_skb(resp);
1308}