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