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