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