blob: 03bfc74745f7192b87deb85f8a1a10523d38a460 [file] [log] [blame]
Thierry Escande7d0911c2013-09-19 17:55:29 +02001/*
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
Samuel Ortizc5da0e42013-09-20 09:05:48 +020016#define pr_fmt(fmt) "digital: %s: " fmt, __func__
17
Thierry Escande7d0911c2013-09-19 17:55:29 +020018#include "digital.h"
19
Mark A. Greera80509c2014-09-23 16:38:11 -070020#define DIGITAL_NFC_DEP_N_RETRY_NACK 2
Mark A. Greer384ab1d2014-09-23 16:38:13 -070021#define DIGITAL_NFC_DEP_N_RETRY_ATN 2
Mark A. Greera80509c2014-09-23 16:38:11 -070022
Thierry Escande7d0911c2013-09-19 17:55:29 +020023#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
Mark A. Greer05afedc2014-09-23 16:38:05 -070038#define DIGITAL_DID_MAX 14
39
Mark A. Greerb08147c2014-09-23 16:38:08 -070040#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
Thierry Escande7d0911c2013-09-19 17:55:29 +020046#define DIGITAL_GB_BIT 0x02
47
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -070048#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
Thierry Escande7d0911c2013-09-19 17:55:29 +020051#define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0)
52
53#define DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT 0x10
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -070054#define DIGITAL_NFC_DEP_PFB_MI_BIT 0x10
55#define DIGITAL_NFC_DEP_PFB_NACK_BIT 0x10
Mark A. Greer05afedc2014-09-23 16:38:05 -070056#define DIGITAL_NFC_DEP_PFB_DID_BIT 0x04
Thierry Escande7d0911c2013-09-19 17:55:29 +020057
58#define DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb) \
59 ((pfb) & DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT)
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -070060#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)
Thierry Escande7d0911c2013-09-19 17:55:29 +020062#define DIGITAL_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08)
Mark A. Greer05afedc2014-09-23 16:38:05 -070063#define DIGITAL_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_DID_BIT)
Thierry Escande7d0911c2013-09-19 17:55:29 +020064#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);
Mark A. Greerc12715a2014-09-23 16:38:10 -0700115static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
116 struct sk_buff *resp);
Thierry Escande7d0911c2013-09-19 17:55:29 +0200117
Mark A. Greerb08147c2014-09-23 16:38:08 -0700118static 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
Thierry Escande7d0911c2013-09-19 17:55:29 +0200144static 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
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -0700175static 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
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -0700193 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
Mark A. Greerc12715a2014-09-23 16:38:10 -0700207static 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
Mark A. Greerdddb3da2014-07-22 20:18:01 -0700273static 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;
Mark A. Greerb15829b2014-09-23 16:38:02 -0700342 int rc;
Mark A. Greerb08147c2014-09-23 16:38:08 -0700343 u8 payload_size, payload_bits;
Mark A. Greerdddb3da2014-07-22 20:18:01 -0700344
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 */
Mark A. Greerb08147c2014-09-23 16:38:08 -0700357
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;
Mark A. Greerdddb3da2014-07-22 20:18:01 -0700364
365 digital_skb_push_dep_sod(ddev, skb);
366
367 ddev->skb_add_crc(skb);
368
Mark A. Greerb15829b2014-09-23 16:38:02 -0700369 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;
Mark A. Greerdddb3da2014-07-22 20:18:01 -0700375}
376
Thierry Escande7d0911c2013-09-19 17:55:29 +0200377static 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;
Mark A. Greerb08147c2014-09-23 16:38:08 -0700382 u8 gb_len, payload_bits;
Thierry Escande7d0911c2013-09-19 17:55:29 +0200383 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
Mark A. Greerb08147c2014-09-23 16:38:08 -0700412 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
Thierry Escande7d0911c2013-09-19 17:55:29 +0200420 rc = nfc_set_remote_general_bytes(ddev->nfc_dev, atr_res->gb, gb_len);
421 if (rc)
422 goto exit;
423
Mark A. Greerdddb3da2014-07-22 20:18:01 -0700424 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
Thierry Escande7d0911c2013-09-19 17:55:29 +0200431 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;
Mark A. Greerb15829b2014-09-23 16:38:02 -0700450 int rc;
Mark A. Greerb08147c2014-09-23 16:38:08 -0700451 u8 payload_bits;
Thierry Escande7d0911c2013-09-19 17:55:29 +0200452
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)
Thierry Escande4f319e32014-01-02 11:58:14 +0100472 memcpy(atr_req->nfcid3, target->nfcid2, NFC_NFCID2_MAXSIZE);
Thierry Escande7d0911c2013-09-19 17:55:29 +0200473 else
Thierry Escande4f319e32014-01-02 11:58:14 +0100474 get_random_bytes(atr_req->nfcid3, NFC_NFCID3_MAXSIZE);
Thierry Escande7d0911c2013-09-19 17:55:29 +0200475
476 atr_req->did = 0;
477 atr_req->bs = 0;
478 atr_req->br = 0;
479
Mark A. Greerb08147c2014-09-23 16:38:08 -0700480 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);
Thierry Escande7d0911c2013-09-19 17:55:29 +0200483
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
Mark A. Greerb15829b2014-09-23 16:38:02 -0700493 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;
Thierry Escande7d0911c2013-09-19 17:55:29 +0200499}
500
Mark A. Greerc12715a2014-09-23 16:38:10 -0700501static 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
Thierry Escande1d984c22016-07-08 15:52:39 +0200525 ddev->saved_skb = pskb_copy(skb, GFP_KERNEL);
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700526
Mark A. Greerc12715a2014-09-23 16:38:10 -0700527 rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
528 data_exch);
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700529 if (rc) {
Mark A. Greerc12715a2014-09-23 16:38:10 -0700530 kfree_skb(skb);
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700531 kfree_skb(ddev->saved_skb);
532 ddev->saved_skb = NULL;
533 }
Mark A. Greerc12715a2014-09-23 16:38:10 -0700534
535 return rc;
536}
537
Mark A. Greera80509c2014-09-23 16:38:11 -0700538static 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
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700570static 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
Thierry Escande7d0911c2013-09-19 17:55:29 +0200601static 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);
Thierry Escande1d984c22016-07-08 15:52:39 +0200629 if (rc)
Mark A. Greerb15829b2014-09-23 16:38:02 -0700630 kfree_skb(skb);
Thierry Escande7d0911c2013-09-19 17:55:29 +0200631
632 return rc;
633}
634
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700635static int digital_in_send_saved_skb(struct nfc_digital_dev *ddev,
636 struct digital_data_exch *data_exch)
637{
Thierry Escande1d984c22016-07-08 15:52:39 +0200638 int rc;
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700639
Thierry Escande1d984c22016-07-08 15:52:39 +0200640 if (!ddev->saved_skb)
641 return -EINVAL;
642
643 skb_get(ddev->saved_skb);
644
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;
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700651}
652
Thierry Escande7d0911c2013-09-19 17:55:29 +0200653static 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;
Thierry Escande7d0911c2013-09-19 17:55:29 +0200665
Thierry Escande3f89fea2016-06-16 20:24:42 +0200666 if ((rc == -EIO || (rc == -ETIMEDOUT && ddev->nack_count)) &&
Mark A. Greera80509c2014-09-23 16:38:11 -0700667 (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) {
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700668 ddev->atn_count = 0;
669
Mark A. Greera80509c2014-09-23 16:38:11 -0700670 rc = digital_in_send_nack(ddev, data_exch);
671 if (rc)
672 goto error;
673
674 return;
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700675 } 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
683 return;
Mark A. Greera80509c2014-09-23 16:38:11 -0700684 }
685
686 goto exit;
Thierry Escande7d0911c2013-09-19 17:55:29 +0200687 }
688
689 rc = digital_skb_pull_dep_sod(ddev, resp);
690 if (rc) {
691 PROTOCOL_ERR("14.4.1.2");
692 goto exit;
693 }
694
Mark A. Greera80509c2014-09-23 16:38:11 -0700695 rc = ddev->skb_check_crc(resp);
696 if (rc) {
697 if ((resp->len >= 4) &&
698 (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) {
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700699 ddev->atn_count = 0;
700
Mark A. Greera80509c2014-09-23 16:38:11 -0700701 rc = digital_in_send_nack(ddev, data_exch);
702 if (rc)
703 goto error;
704
705 kfree_skb(resp);
706
707 return;
708 }
709
710 PROTOCOL_ERR("14.4.1.6");
711 goto error;
712 }
713
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700714 ddev->atn_count = 0;
Mark A. Greera80509c2014-09-23 16:38:11 -0700715 ddev->nack_count = 0;
716
Mark A. Greerb08147c2014-09-23 16:38:08 -0700717 if (resp->len > ddev->local_payload_max) {
718 rc = -EMSGSIZE;
719 goto exit;
720 }
721
Mark A. Greer6ce30662014-09-23 16:38:03 -0700722 size = sizeof(struct digital_dep_req_res);
Thierry Escande7d0911c2013-09-19 17:55:29 +0200723 dep_res = (struct digital_dep_req_res *)resp->data;
724
Mark A. Greer6ce30662014-09-23 16:38:03 -0700725 if (resp->len < size || dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN ||
Thierry Escande7d0911c2013-09-19 17:55:29 +0200726 dep_res->cmd != DIGITAL_CMD_DEP_RES) {
727 rc = -EIO;
728 goto error;
729 }
730
731 pfb = dep_res->pfb;
732
Mark A. Greer3bc3f882014-09-23 16:38:04 -0700733 if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
734 PROTOCOL_ERR("14.8.2.1");
735 rc = -EIO;
736 goto error;
737 }
Mark A. Greer6ce30662014-09-23 16:38:03 -0700738
Mark A. Greer3e6b0de2014-09-23 16:38:06 -0700739 if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
740 rc = -EIO;
741 goto exit;
742 }
743
Mark A. Greer6ce30662014-09-23 16:38:03 -0700744 if (size > resp->len) {
745 rc = -EIO;
746 goto error;
747 }
748
749 skb_pull(resp, size);
750
Thierry Escande7d0911c2013-09-19 17:55:29 +0200751 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);
Mark A. Greerc12715a2014-09-23 16:38:10 -0700761
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700762 kfree_skb(ddev->saved_skb);
763 ddev->saved_skb = NULL;
764
Mark A. Greerc12715a2014-09-23 16:38:10 -0700765 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
Thierry Escande7d0911c2013-09-19 17:55:29 +0200781 rc = 0;
782 break;
783
784 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
Thierry Escandee073eb62016-07-08 15:52:43 +0200785 if (DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) {
786 PROTOCOL_ERR("14.12.4.5");
787 rc = -EIO;
788 goto exit;
789 }
790
Mark A. Greer485fdc92014-09-23 16:38:07 -0700791 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
792 PROTOCOL_ERR("14.12.3.3");
793 rc = -EIO;
794 goto exit;
795 }
796
797 ddev->curr_nfc_dep_pni =
798 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
799
Thierry Escandee073eb62016-07-08 15:52:43 +0200800 if (!ddev->chaining_skb) {
801 PROTOCOL_ERR("14.12.4.3");
802 rc = -EIO;
803 goto exit;
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -0700804 }
805
Thierry Escandee073eb62016-07-08 15:52:43 +0200806 /* The initiator has received a valid ACK. Free the last sent
807 * PDU and keep on sending chained skb.
808 */
809 kfree_skb(ddev->saved_skb);
810 ddev->saved_skb = NULL;
811
812 rc = digital_in_send_dep_req(ddev, NULL,
813 ddev->chaining_skb,
814 ddev->data_exch);
815 if (rc)
816 goto error;
817
818 goto free_resp;
Thierry Escande7d0911c2013-09-19 17:55:29 +0200819
820 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700821 if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) { /* ATN */
822 rc = digital_in_send_saved_skb(ddev, data_exch);
Thierry Escande1d984c22016-07-08 15:52:39 +0200823 if (rc)
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700824 goto error;
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700825
826 return;
Thierry Escande7d0911c2013-09-19 17:55:29 +0200827 }
828
Mark A. Greer6ce30662014-09-23 16:38:03 -0700829 rc = digital_in_send_rtox(ddev, data_exch, resp->data[0]);
Thierry Escande7d0911c2013-09-19 17:55:29 +0200830 if (rc)
831 goto error;
832
833 kfree_skb(resp);
834 return;
835 }
836
Thierry Escande7d0911c2013-09-19 17:55:29 +0200837exit:
838 data_exch->cb(data_exch->cb_context, resp, rc);
839
840error:
841 kfree(data_exch);
842
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -0700843 kfree_skb(ddev->chaining_skb);
844 ddev->chaining_skb = NULL;
845
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700846 kfree_skb(ddev->saved_skb);
847 ddev->saved_skb = NULL;
848
Thierry Escande7d0911c2013-09-19 17:55:29 +0200849 if (rc)
850 kfree_skb(resp);
Thierry Escandee073eb62016-07-08 15:52:43 +0200851
852 return;
853
854free_resp:
855 dev_kfree_skb(resp);
Thierry Escande7d0911c2013-09-19 17:55:29 +0200856}
857
858int digital_in_send_dep_req(struct nfc_digital_dev *ddev,
859 struct nfc_target *target, struct sk_buff *skb,
860 struct digital_data_exch *data_exch)
861{
862 struct digital_dep_req_res *dep_req;
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -0700863 struct sk_buff *chaining_skb, *tmp_skb;
864 int rc;
Thierry Escande7d0911c2013-09-19 17:55:29 +0200865
866 skb_push(skb, sizeof(struct digital_dep_req_res));
867
868 dep_req = (struct digital_dep_req_res *)skb->data;
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -0700869
Thierry Escande7d0911c2013-09-19 17:55:29 +0200870 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
871 dep_req->cmd = DIGITAL_CMD_DEP_REQ;
872 dep_req->pfb = ddev->curr_nfc_dep_pni;
873
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700874 ddev->atn_count = 0;
Mark A. Greera80509c2014-09-23 16:38:11 -0700875 ddev->nack_count = 0;
876
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -0700877 chaining_skb = ddev->chaining_skb;
Thierry Escande7d0911c2013-09-19 17:55:29 +0200878
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -0700879 tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_req, data_exch);
880 if (IS_ERR(tmp_skb))
881 return PTR_ERR(tmp_skb);
Thierry Escande7d0911c2013-09-19 17:55:29 +0200882
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -0700883 digital_skb_push_dep_sod(ddev, tmp_skb);
884
885 ddev->skb_add_crc(tmp_skb);
886
Thierry Escande1d984c22016-07-08 15:52:39 +0200887 ddev->saved_skb = pskb_copy(tmp_skb, GFP_KERNEL);
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700888
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -0700889 rc = digital_in_send_cmd(ddev, tmp_skb, 1500, digital_in_recv_dep_res,
890 data_exch);
891 if (rc) {
892 if (tmp_skb != skb)
893 kfree_skb(tmp_skb);
894
895 kfree_skb(chaining_skb);
896 ddev->chaining_skb = NULL;
Mark A. Greer384ab1d2014-09-23 16:38:13 -0700897
898 kfree_skb(ddev->saved_skb);
899 ddev->saved_skb = NULL;
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -0700900 }
901
902 return rc;
Thierry Escande7d0911c2013-09-19 17:55:29 +0200903}
Thierry Escande1c7a4c22013-09-19 17:55:30 +0200904
Thierry Escandeb711ad52014-01-06 23:34:48 +0100905static void digital_tg_set_rf_tech(struct nfc_digital_dev *ddev, u8 rf_tech)
906{
907 ddev->curr_rf_tech = rf_tech;
908
909 ddev->skb_add_crc = digital_skb_add_crc_none;
910 ddev->skb_check_crc = digital_skb_check_crc_none;
911
912 if (DIGITAL_DRV_CAPS_TG_CRC(ddev))
913 return;
914
915 switch (ddev->curr_rf_tech) {
916 case NFC_DIGITAL_RF_TECH_106A:
917 ddev->skb_add_crc = digital_skb_add_crc_a;
918 ddev->skb_check_crc = digital_skb_check_crc_a;
919 break;
920
921 case NFC_DIGITAL_RF_TECH_212F:
922 case NFC_DIGITAL_RF_TECH_424F:
923 ddev->skb_add_crc = digital_skb_add_crc_f;
924 ddev->skb_check_crc = digital_skb_check_crc_f;
925 break;
926
927 default:
928 break;
929 }
930}
931
Mark A. Greerc12715a2014-09-23 16:38:10 -0700932static int digital_tg_send_ack(struct nfc_digital_dev *ddev,
933 struct digital_data_exch *data_exch)
934{
935 struct digital_dep_req_res *dep_res;
936 struct sk_buff *skb;
937 int rc;
938
939 skb = digital_skb_alloc(ddev, 1);
940 if (!skb)
941 return -ENOMEM;
942
943 skb_push(skb, sizeof(struct digital_dep_req_res));
944
945 dep_res = (struct digital_dep_req_res *)skb->data;
946
947 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
948 dep_res->cmd = DIGITAL_CMD_DEP_RES;
949 dep_res->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
950 ddev->curr_nfc_dep_pni;
951
952 if (ddev->did) {
953 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
954
955 memcpy(skb_put(skb, sizeof(ddev->did)), &ddev->did,
956 sizeof(ddev->did));
957 }
958
959 ddev->curr_nfc_dep_pni =
960 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
961
962 digital_skb_push_dep_sod(ddev, skb);
963
964 ddev->skb_add_crc(skb);
965
Thierry Escande1d984c22016-07-08 15:52:39 +0200966 ddev->saved_skb = pskb_copy(skb, GFP_KERNEL);
Mark A. Greer49dbb142014-09-23 16:38:12 -0700967
Mark A. Greerc12715a2014-09-23 16:38:10 -0700968 rc = digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
969 data_exch);
Mark A. Greer49dbb142014-09-23 16:38:12 -0700970 if (rc) {
Mark A. Greerc12715a2014-09-23 16:38:10 -0700971 kfree_skb(skb);
Mark A. Greer49dbb142014-09-23 16:38:12 -0700972 kfree_skb(ddev->saved_skb);
973 ddev->saved_skb = NULL;
974 }
Mark A. Greerc12715a2014-09-23 16:38:10 -0700975
976 return rc;
977}
978
Mark A. Greer9b5ec0f2014-09-23 16:38:14 -0700979static int digital_tg_send_atn(struct nfc_digital_dev *ddev)
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_SUPERVISOR_PDU;
996
997 if (ddev->did) {
998 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
999
1000 memcpy(skb_put(skb, sizeof(ddev->did)), &ddev->did,
1001 sizeof(ddev->did));
1002 }
1003
1004 digital_skb_push_dep_sod(ddev, skb);
1005
1006 ddev->skb_add_crc(skb);
1007
1008 rc = digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
1009 NULL);
1010 if (rc)
1011 kfree_skb(skb);
1012
1013 return rc;
1014}
1015
Mark A. Greer49dbb142014-09-23 16:38:12 -07001016static int digital_tg_send_saved_skb(struct nfc_digital_dev *ddev)
1017{
Thierry Escande1d984c22016-07-08 15:52:39 +02001018 int rc;
Mark A. Greer49dbb142014-09-23 16:38:12 -07001019
Thierry Escande1d984c22016-07-08 15:52:39 +02001020 if (!ddev->saved_skb)
1021 return -EINVAL;
1022
1023 skb_get(ddev->saved_skb);
1024
1025 rc = digital_tg_send_cmd(ddev, ddev->saved_skb, 1500,
1026 digital_tg_recv_dep_req, NULL);
1027 if (rc)
1028 kfree_skb(ddev->saved_skb);
1029
1030 return rc;
Mark A. Greer49dbb142014-09-23 16:38:12 -07001031}
1032
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001033static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
1034 struct sk_buff *resp)
1035{
1036 int rc;
1037 struct digital_dep_req_res *dep_req;
Mark A. Greer6ce30662014-09-23 16:38:03 -07001038 u8 pfb;
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001039 size_t size;
1040
1041 if (IS_ERR(resp)) {
1042 rc = PTR_ERR(resp);
1043 resp = NULL;
1044 goto exit;
1045 }
1046
1047 rc = ddev->skb_check_crc(resp);
1048 if (rc) {
1049 PROTOCOL_ERR("14.4.1.6");
1050 goto exit;
1051 }
1052
1053 rc = digital_skb_pull_dep_sod(ddev, resp);
1054 if (rc) {
1055 PROTOCOL_ERR("14.4.1.2");
1056 goto exit;
1057 }
1058
Mark A. Greerb08147c2014-09-23 16:38:08 -07001059 if (resp->len > ddev->local_payload_max) {
1060 rc = -EMSGSIZE;
1061 goto exit;
1062 }
1063
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001064 size = sizeof(struct digital_dep_req_res);
1065 dep_req = (struct digital_dep_req_res *)resp->data;
1066
1067 if (resp->len < size || dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1068 dep_req->cmd != DIGITAL_CMD_DEP_REQ) {
1069 rc = -EIO;
1070 goto exit;
1071 }
1072
Mark A. Greer6ce30662014-09-23 16:38:03 -07001073 pfb = dep_req->pfb;
1074
Mark A. Greer05afedc2014-09-23 16:38:05 -07001075 if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
1076 if (ddev->did && (ddev->did == resp->data[3])) {
1077 size++;
1078 } else {
1079 rc = -EIO;
1080 goto exit;
1081 }
1082 } else if (ddev->did) {
1083 rc = -EIO;
1084 goto exit;
1085 }
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001086
Mark A. Greer3e6b0de2014-09-23 16:38:06 -07001087 if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
1088 rc = -EIO;
1089 goto exit;
1090 }
1091
Mark A. Greer6ce30662014-09-23 16:38:03 -07001092 if (size > resp->len) {
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001093 rc = -EIO;
1094 goto exit;
1095 }
1096
Mark A. Greer6ce30662014-09-23 16:38:03 -07001097 skb_pull(resp, size);
1098
1099 switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001100 case DIGITAL_NFC_DEP_PFB_I_PDU:
Samuel Ortiz26042532013-09-20 16:56:40 +02001101 pr_debug("DIGITAL_NFC_DEP_PFB_I_PDU\n");
Mark A. Greer485fdc92014-09-23 16:38:07 -07001102
Thierry Escandef23a9862016-07-08 15:52:41 +02001103 if (ddev->atn_count) {
1104 /* The target has received (and replied to) at least one
1105 * ATN DEP_REQ.
1106 */
1107 ddev->atn_count = 0;
1108
1109 /* pni of resp PDU equal to the target current pni - 1
1110 * means resp is the previous DEP_REQ PDU received from
1111 * the initiator so the target replies with saved_skb
1112 * which is the previous DEP_RES saved in
1113 * digital_tg_send_dep_res().
1114 */
1115 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) ==
1116 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni - 1)) {
1117 rc = digital_tg_send_saved_skb(ddev);
1118 if (rc)
1119 goto exit;
1120
1121 goto free_resp;
1122 }
1123
1124 /* atn_count > 0 and PDU pni != curr_nfc_dep_pni - 1
1125 * means the target probably did not received the last
1126 * DEP_REQ PDU sent by the initiator. The target
1127 * fallbacks to normal processing then.
1128 */
1129 }
1130
1131 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
Mark A. Greer485fdc92014-09-23 16:38:07 -07001132 PROTOCOL_ERR("14.12.3.4");
1133 rc = -EIO;
1134 goto exit;
1135 }
1136
Mark A. Greer49dbb142014-09-23 16:38:12 -07001137 kfree_skb(ddev->saved_skb);
1138 ddev->saved_skb = NULL;
1139
Mark A. Greerc12715a2014-09-23 16:38:10 -07001140 resp = digital_recv_dep_data_gather(ddev, pfb, resp,
1141 digital_tg_send_ack, NULL);
1142 if (IS_ERR(resp)) {
1143 rc = PTR_ERR(resp);
1144 resp = NULL;
1145 goto exit;
1146 }
1147
1148 /* If resp is NULL then we're still chaining so return and
1149 * wait for the next part of the PDU. Else, the PDU is
1150 * complete so pass it up.
1151 */
1152 if (!resp)
1153 return;
1154
Mark A. Greer485fdc92014-09-23 16:38:07 -07001155 rc = 0;
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001156 break;
1157 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
Thierry Escande482333b2016-07-08 15:52:42 +02001158 if (DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) { /* NACK */
1159 if (DIGITAL_NFC_DEP_PFB_PNI(pfb + 1) !=
1160 ddev->curr_nfc_dep_pni) {
Mark A. Greer49dbb142014-09-23 16:38:12 -07001161 rc = -EIO;
1162 goto exit;
1163 }
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -07001164
Mark A. Greer9b5ec0f2014-09-23 16:38:14 -07001165 ddev->atn_count = 0;
1166
Mark A. Greer49dbb142014-09-23 16:38:12 -07001167 rc = digital_tg_send_saved_skb(ddev);
Thierry Escande1d984c22016-07-08 15:52:39 +02001168 if (rc)
Mark A. Greer49dbb142014-09-23 16:38:12 -07001169 goto exit;
Thierry Escande482333b2016-07-08 15:52:42 +02001170
1171 goto free_resp;
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -07001172 }
1173
Thierry Escande482333b2016-07-08 15:52:42 +02001174 /* ACK */
1175 if (ddev->atn_count) {
1176 /* The target has previously recevied one or more ATN
1177 * PDUs.
1178 */
1179 ddev->atn_count = 0;
1180
1181 /* If the ACK PNI is equal to the target PNI - 1 means
1182 * that the initiator did not receive the previous PDU
1183 * sent by the target so re-send it.
1184 */
1185 if (DIGITAL_NFC_DEP_PFB_PNI(pfb + 1) ==
1186 ddev->curr_nfc_dep_pni) {
1187 rc = digital_tg_send_saved_skb(ddev);
1188 if (rc)
1189 goto exit;
1190
1191 goto free_resp;
1192 }
1193
1194 /* Otherwise, the target did not receive the previous
1195 * ACK PDU from the initiator. Fallback to normal
1196 * processing of chained PDU then.
1197 */
1198 }
1199
1200 /* Keep on sending chained PDU */
1201 if (!ddev->chaining_skb ||
1202 DIGITAL_NFC_DEP_PFB_PNI(pfb) !=
1203 ddev->curr_nfc_dep_pni) {
1204 rc = -EIO;
1205 goto exit;
1206 }
1207
1208 kfree_skb(ddev->saved_skb);
1209 ddev->saved_skb = NULL;
1210
1211 rc = digital_tg_send_dep_res(ddev, ddev->chaining_skb);
1212 if (rc)
1213 goto exit;
1214
1215 goto free_resp;
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001216 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
Mark A. Greer9b5ec0f2014-09-23 16:38:14 -07001217 if (DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) {
1218 rc = -EINVAL;
1219 goto exit;
1220 }
1221
1222 rc = digital_tg_send_atn(ddev);
1223 if (rc)
1224 goto exit;
1225
1226 ddev->atn_count++;
1227
1228 kfree_skb(resp);
1229 return;
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001230 }
1231
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001232 rc = nfc_tm_data_received(ddev->nfc_dev, resp);
1233
1234exit:
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -07001235 kfree_skb(ddev->chaining_skb);
1236 ddev->chaining_skb = NULL;
1237
Mark A. Greer9b5ec0f2014-09-23 16:38:14 -07001238 ddev->atn_count = 0;
1239
Mark A. Greer49dbb142014-09-23 16:38:12 -07001240 kfree_skb(ddev->saved_skb);
1241 ddev->saved_skb = NULL;
1242
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001243 if (rc)
1244 kfree_skb(resp);
Thierry Escandef23a9862016-07-08 15:52:41 +02001245
1246 return;
1247
1248free_resp:
1249 dev_kfree_skb(resp);
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001250}
1251
1252int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb)
1253{
1254 struct digital_dep_req_res *dep_res;
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -07001255 struct sk_buff *chaining_skb, *tmp_skb;
1256 int rc;
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001257
1258 skb_push(skb, sizeof(struct digital_dep_req_res));
Mark A. Greerb08147c2014-09-23 16:38:08 -07001259
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001260 dep_res = (struct digital_dep_req_res *)skb->data;
1261
1262 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1263 dep_res->cmd = DIGITAL_CMD_DEP_RES;
1264 dep_res->pfb = ddev->curr_nfc_dep_pni;
1265
Mark A. Greer05afedc2014-09-23 16:38:05 -07001266 if (ddev->did) {
1267 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
1268
1269 memcpy(skb_put(skb, sizeof(ddev->did)), &ddev->did,
1270 sizeof(ddev->did));
1271 }
1272
Mark A. Greer485fdc92014-09-23 16:38:07 -07001273 ddev->curr_nfc_dep_pni =
1274 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
1275
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -07001276 chaining_skb = ddev->chaining_skb;
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001277
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -07001278 tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_res, NULL);
1279 if (IS_ERR(tmp_skb))
1280 return PTR_ERR(tmp_skb);
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001281
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -07001282 digital_skb_push_dep_sod(ddev, tmp_skb);
1283
1284 ddev->skb_add_crc(tmp_skb);
1285
Thierry Escande1d984c22016-07-08 15:52:39 +02001286 ddev->saved_skb = pskb_copy(tmp_skb, GFP_KERNEL);
Mark A. Greer49dbb142014-09-23 16:38:12 -07001287
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -07001288 rc = digital_tg_send_cmd(ddev, tmp_skb, 1500, digital_tg_recv_dep_req,
1289 NULL);
1290 if (rc) {
1291 if (tmp_skb != skb)
1292 kfree_skb(tmp_skb);
1293
1294 kfree_skb(chaining_skb);
1295 ddev->chaining_skb = NULL;
Mark A. Greer49dbb142014-09-23 16:38:12 -07001296
1297 kfree_skb(ddev->saved_skb);
1298 ddev->saved_skb = NULL;
Mark A. Greer3bd2a5b2014-09-23 16:38:09 -07001299 }
1300
1301 return rc;
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001302}
1303
1304static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev,
1305 void *arg, struct sk_buff *resp)
1306{
Thierry Escande67af1d72014-01-02 11:58:13 +01001307 u8 rf_tech = (unsigned long)arg;
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001308
1309 if (IS_ERR(resp))
1310 return;
1311
Thierry Escandeb711ad52014-01-06 23:34:48 +01001312 digital_tg_set_rf_tech(ddev, rf_tech);
1313
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001314 digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
1315
1316 digital_tg_listen(ddev, 1500, digital_tg_recv_dep_req, NULL);
1317
1318 dev_kfree_skb(resp);
1319}
1320
1321static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did,
1322 u8 rf_tech)
1323{
1324 struct digital_psl_res *psl_res;
1325 struct sk_buff *skb;
1326 int rc;
1327
1328 skb = digital_skb_alloc(ddev, sizeof(struct digital_psl_res));
1329 if (!skb)
1330 return -ENOMEM;
1331
1332 skb_put(skb, sizeof(struct digital_psl_res));
1333
1334 psl_res = (struct digital_psl_res *)skb->data;
1335
1336 psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1337 psl_res->cmd = DIGITAL_CMD_PSL_RES;
1338 psl_res->did = did;
1339
1340 digital_skb_push_dep_sod(ddev, skb);
1341
1342 ddev->skb_add_crc(skb);
1343
Mark A. Greer485fdc92014-09-23 16:38:07 -07001344 ddev->curr_nfc_dep_pni = 0;
1345
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001346 rc = digital_tg_send_cmd(ddev, skb, 0, digital_tg_send_psl_res_complete,
Thierry Escande67af1d72014-01-02 11:58:13 +01001347 (void *)(unsigned long)rf_tech);
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001348 if (rc)
1349 kfree_skb(skb);
1350
1351 return rc;
1352}
1353
1354static void digital_tg_recv_psl_req(struct nfc_digital_dev *ddev, void *arg,
1355 struct sk_buff *resp)
1356{
1357 int rc;
1358 struct digital_psl_req *psl_req;
1359 u8 rf_tech;
Mark A. Greerb08147c2014-09-23 16:38:08 -07001360 u8 dsi, payload_size, payload_bits;
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001361
1362 if (IS_ERR(resp)) {
1363 rc = PTR_ERR(resp);
1364 resp = NULL;
1365 goto exit;
1366 }
1367
1368 rc = ddev->skb_check_crc(resp);
1369 if (rc) {
1370 PROTOCOL_ERR("14.4.1.6");
1371 goto exit;
1372 }
1373
1374 rc = digital_skb_pull_dep_sod(ddev, resp);
1375 if (rc) {
1376 PROTOCOL_ERR("14.4.1.2");
1377 goto exit;
1378 }
1379
1380 psl_req = (struct digital_psl_req *)resp->data;
1381
1382 if (resp->len != sizeof(struct digital_psl_req) ||
1383 psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1384 psl_req->cmd != DIGITAL_CMD_PSL_REQ) {
1385 rc = -EIO;
1386 goto exit;
1387 }
1388
1389 dsi = (psl_req->brs >> 3) & 0x07;
1390 switch (dsi) {
1391 case 0:
1392 rf_tech = NFC_DIGITAL_RF_TECH_106A;
1393 break;
1394 case 1:
1395 rf_tech = NFC_DIGITAL_RF_TECH_212F;
1396 break;
1397 case 2:
1398 rf_tech = NFC_DIGITAL_RF_TECH_424F;
1399 break;
1400 default:
Masanari Iida77d84ff2013-12-09 00:22:53 +09001401 pr_err("Unsupported dsi value %d\n", dsi);
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001402 goto exit;
1403 }
1404
Mark A. Greerb08147c2014-09-23 16:38:08 -07001405 payload_bits = DIGITAL_PAYLOAD_FSL_TO_BITS(psl_req->fsl);
1406 payload_size = digital_payload_bits_to_size(payload_bits);
1407
1408 if (!payload_size || (payload_size > min(ddev->local_payload_max,
1409 ddev->remote_payload_max))) {
1410 rc = -EINVAL;
1411 goto exit;
1412 }
1413
1414 ddev->local_payload_max = payload_size;
1415 ddev->remote_payload_max = payload_size;
1416
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001417 rc = digital_tg_send_psl_res(ddev, psl_req->did, rf_tech);
1418
1419exit:
1420 kfree_skb(resp);
1421}
1422
1423static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev,
1424 void *arg, struct sk_buff *resp)
1425{
1426 int offset;
1427
1428 if (IS_ERR(resp)) {
1429 digital_poll_next_tech(ddev);
1430 return;
1431 }
1432
1433 offset = 2;
1434 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB)
1435 offset++;
1436
Mark A. Greer9b5ec0f2014-09-23 16:38:14 -07001437 ddev->atn_count = 0;
1438
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001439 if (resp->data[offset] == DIGITAL_CMD_PSL_REQ)
1440 digital_tg_recv_psl_req(ddev, arg, resp);
1441 else
1442 digital_tg_recv_dep_req(ddev, arg, resp);
1443}
1444
1445static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev,
1446 struct digital_atr_req *atr_req)
1447{
1448 struct digital_atr_res *atr_res;
1449 struct sk_buff *skb;
Mark A. Greerb08147c2014-09-23 16:38:08 -07001450 u8 *gb, payload_bits;
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001451 size_t gb_len;
1452 int rc;
1453
1454 gb = nfc_get_local_general_bytes(ddev->nfc_dev, &gb_len);
1455 if (!gb)
1456 gb_len = 0;
1457
1458 skb = digital_skb_alloc(ddev, sizeof(struct digital_atr_res) + gb_len);
1459 if (!skb)
1460 return -ENOMEM;
1461
1462 skb_put(skb, sizeof(struct digital_atr_res));
1463 atr_res = (struct digital_atr_res *)skb->data;
1464
1465 memset(atr_res, 0, sizeof(struct digital_atr_res));
1466
1467 atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1468 atr_res->cmd = DIGITAL_CMD_ATR_RES;
1469 memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3));
1470 atr_res->to = 8;
Mark A. Greerb08147c2014-09-23 16:38:08 -07001471
1472 ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX;
1473 payload_bits = digital_payload_size_to_bits(ddev->local_payload_max);
1474 atr_res->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits);
1475
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001476 if (gb_len) {
1477 skb_put(skb, gb_len);
1478
1479 atr_res->pp |= DIGITAL_GB_BIT;
1480 memcpy(atr_res->gb, gb, gb_len);
1481 }
1482
1483 digital_skb_push_dep_sod(ddev, skb);
1484
1485 ddev->skb_add_crc(skb);
1486
Mark A. Greer485fdc92014-09-23 16:38:07 -07001487 ddev->curr_nfc_dep_pni = 0;
1488
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001489 rc = digital_tg_send_cmd(ddev, skb, 999,
1490 digital_tg_send_atr_res_complete, NULL);
Mark A. Greerb15829b2014-09-23 16:38:02 -07001491 if (rc)
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001492 kfree_skb(skb);
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001493
1494 return rc;
1495}
1496
1497void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg,
1498 struct sk_buff *resp)
1499{
1500 int rc;
1501 struct digital_atr_req *atr_req;
1502 size_t gb_len, min_size;
Mark A. Greerb08147c2014-09-23 16:38:08 -07001503 u8 poll_tech_count, payload_bits;
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001504
1505 if (IS_ERR(resp)) {
1506 rc = PTR_ERR(resp);
1507 resp = NULL;
1508 goto exit;
1509 }
1510
1511 if (!resp->len) {
1512 rc = -EIO;
1513 goto exit;
1514 }
1515
1516 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) {
1517 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2;
Thierry Escandeb711ad52014-01-06 23:34:48 +01001518 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_106A);
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001519 } else {
1520 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1;
Thierry Escandeb711ad52014-01-06 23:34:48 +01001521 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_212F);
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001522 }
1523
1524 if (resp->len < min_size) {
1525 rc = -EIO;
1526 goto exit;
1527 }
1528
Thierry Escande48e10442014-01-06 23:34:37 +01001529 ddev->curr_protocol = NFC_PROTO_NFC_DEP_MASK;
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001530
1531 rc = ddev->skb_check_crc(resp);
1532 if (rc) {
1533 PROTOCOL_ERR("14.4.1.6");
1534 goto exit;
1535 }
1536
1537 rc = digital_skb_pull_dep_sod(ddev, resp);
1538 if (rc) {
1539 PROTOCOL_ERR("14.4.1.2");
1540 goto exit;
1541 }
1542
1543 atr_req = (struct digital_atr_req *)resp->data;
1544
1545 if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
Mark A. Greer05afedc2014-09-23 16:38:05 -07001546 atr_req->cmd != DIGITAL_CMD_ATR_REQ ||
1547 atr_req->did > DIGITAL_DID_MAX) {
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001548 rc = -EINVAL;
1549 goto exit;
1550 }
1551
Mark A. Greerb08147c2014-09-23 16:38:08 -07001552 payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_req->pp);
1553 ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
1554
1555 if (!ddev->remote_payload_max) {
1556 rc = -EINVAL;
1557 goto exit;
1558 }
1559
Mark A. Greer05afedc2014-09-23 16:38:05 -07001560 ddev->did = atr_req->did;
1561
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001562 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1563 NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED);
1564 if (rc)
1565 goto exit;
1566
1567 rc = digital_tg_send_atr_res(ddev, atr_req);
1568 if (rc)
1569 goto exit;
1570
1571 gb_len = resp->len - sizeof(struct digital_atr_req);
Mark A. Greer0529a7a2014-07-02 09:03:49 -07001572
1573 poll_tech_count = ddev->poll_tech_count;
1574 ddev->poll_tech_count = 0;
1575
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001576 rc = nfc_tm_activated(ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
1577 NFC_COMM_PASSIVE, atr_req->gb, gb_len);
Mark A. Greer0529a7a2014-07-02 09:03:49 -07001578 if (rc) {
1579 ddev->poll_tech_count = poll_tech_count;
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001580 goto exit;
Mark A. Greer0529a7a2014-07-02 09:03:49 -07001581 }
Thierry Escande1c7a4c22013-09-19 17:55:30 +02001582
1583 rc = 0;
1584exit:
1585 if (rc)
1586 digital_poll_next_tech(ddev);
1587
1588 dev_kfree_skb(resp);
1589}