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