projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
NFC: digital: Implement NFC-DEP max payload lengths
[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
20#define DIGITAL_NFC_DEP_FRAME_DIR_OUT 0xD4
21#define DIGITAL_NFC_DEP_FRAME_DIR_IN 0xD5
22
23#define DIGITAL_NFC_DEP_NFCA_SOD_SB 0xF0
24
25#define DIGITAL_CMD_ATR_REQ 0x00
26#define DIGITAL_CMD_ATR_RES 0x01
27#define DIGITAL_CMD_PSL_REQ 0x04
28#define DIGITAL_CMD_PSL_RES 0x05
29#define DIGITAL_CMD_DEP_REQ 0x06
30#define DIGITAL_CMD_DEP_RES 0x07
31
32#define DIGITAL_ATR_REQ_MIN_SIZE 16
33#define DIGITAL_ATR_REQ_MAX_SIZE 64
34
05afedcb
MG		 35#define DIGITAL_DID_MAX 14
36
b08147cb
MG		 37#define DIGITAL_PAYLOAD_SIZE_MAX 254
38#define DIGITAL_PAYLOAD_BITS_TO_PP(s) (((s) & 0x3) << 4)
39#define DIGITAL_PAYLOAD_PP_TO_BITS(s) (((s) >> 4) & 0x3)
40#define DIGITAL_PAYLOAD_BITS_TO_FSL(s) ((s) & 0x3)
41#define DIGITAL_PAYLOAD_FSL_TO_BITS(s) ((s) & 0x3)
42
7d0911c0
TE		 43#define DIGITAL_GB_BIT 0x02
44
45#define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0)
46
47#define DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT 0x10
05afedcb 48#define DIGITAL_NFC_DEP_PFB_DID_BIT 0x04
7d0911c0
TE		 49
50#define DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb) \
51 ((pfb) & DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT)
52#define DIGITAL_NFC_DEP_MI_BIT_SET(pfb) ((pfb) & 0x10)
53#define DIGITAL_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08)
05afedcb 54#define DIGITAL_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_DID_BIT)
7d0911c0
TE		 55#define DIGITAL_NFC_DEP_PFB_PNI(pfb) ((pfb) & 0x03)
56
57#define DIGITAL_NFC_DEP_PFB_I_PDU 0x00
58#define DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU 0x40
59#define DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU 0x80
60
61struct digital_atr_req {
62 u8 dir;
63 u8 cmd;
64 u8 nfcid3[10];
65 u8 did;
66 u8 bs;
67 u8 br;
68 u8 pp;
69 u8 gb[0];
70} __packed;
71
72struct digital_atr_res {
73 u8 dir;
74 u8 cmd;
75 u8 nfcid3[10];
76 u8 did;
77 u8 bs;
78 u8 br;
79 u8 to;
80 u8 pp;
81 u8 gb[0];
82} __packed;
83
84struct digital_psl_req {
85 u8 dir;
86 u8 cmd;
87 u8 did;
88 u8 brs;
89 u8 fsl;
90} __packed;
91
92struct digital_psl_res {
93 u8 dir;
94 u8 cmd;
95 u8 did;
96} __packed;
97
98struct digital_dep_req_res {
99 u8 dir;
100 u8 cmd;
101 u8 pfb;
102} __packed;
103
104static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
105 struct sk_buff *resp);
106
b08147cb
MG		 107static const u8 digital_payload_bits_map[4] = {
108 [0] = 64,
109 [1] = 128,
110 [2] = 192,
111 [3] = 254
112};
113
114static u8 digital_payload_bits_to_size(u8 payload_bits)
115{
116 if (payload_bits >= ARRAY_SIZE(digital_payload_bits_map))
117 return 0;
118
119 return digital_payload_bits_map[payload_bits];
120}
121
122static u8 digital_payload_size_to_bits(u8 payload_size)
123{
124 int i;
125
126 for (i = 0; i < ARRAY_SIZE(digital_payload_bits_map); i++)
127 if (digital_payload_bits_map[i] == payload_size)
128 return i;
129
130 return 0xff;
131}
132
7d0911c0
TE		 133static void digital_skb_push_dep_sod(struct nfc_digital_dev *ddev,
134 struct sk_buff *skb)
135{
136 skb_push(skb, sizeof(u8));
137
138 skb->data[0] = skb->len;
139
140 if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
141 *skb_push(skb, sizeof(u8)) = DIGITAL_NFC_DEP_NFCA_SOD_SB;
142}
143
144static int digital_skb_pull_dep_sod(struct nfc_digital_dev *ddev,
145 struct sk_buff *skb)
146{
147 u8 size;
148
149 if (skb->len < 2)
150 return -EIO;
151
152 if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
153 skb_pull(skb, sizeof(u8));
154
155 size = skb->data[0];
156 if (size != skb->len)
157 return -EIO;
158
159 skb_pull(skb, sizeof(u8));
160
161 return 0;
162}
163
dddb3da0
MG		 164static void digital_in_recv_psl_res(struct nfc_digital_dev *ddev, void *arg,
165 struct sk_buff *resp)
166{
167 struct nfc_target *target = arg;
168 struct digital_psl_res *psl_res;
169 int rc;
170
171 if (IS_ERR(resp)) {
172 rc = PTR_ERR(resp);
173 resp = NULL;
174 goto exit;
175 }
176
177 rc = ddev->skb_check_crc(resp);
178 if (rc) {
179 PROTOCOL_ERR("14.4.1.6");
180 goto exit;
181 }
182
183 rc = digital_skb_pull_dep_sod(ddev, resp);
184 if (rc) {
185 PROTOCOL_ERR("14.4.1.2");
186 goto exit;
187 }
188
189 psl_res = (struct digital_psl_res *)resp->data;
190
191 if ((resp->len != sizeof(*psl_res)) ||
192 (psl_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN) ||
193 (psl_res->cmd != DIGITAL_CMD_PSL_RES)) {
194 rc = -EIO;
195 goto exit;
196 }
197
198 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
199 NFC_DIGITAL_RF_TECH_424F);
200 if (rc)
201 goto exit;
202
203 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
204 NFC_DIGITAL_FRAMING_NFCF_NFC_DEP);
205 if (rc)
206 goto exit;
207
208 if (!DIGITAL_DRV_CAPS_IN_CRC(ddev) &&
209 (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)) {
210 ddev->skb_add_crc = digital_skb_add_crc_f;
211 ddev->skb_check_crc = digital_skb_check_crc_f;
212 }
213
214 ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_424F;
215
216 nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
217 NFC_RF_INITIATOR);
218
219 ddev->curr_nfc_dep_pni = 0;
220
221exit:
222 dev_kfree_skb(resp);
223
224 if (rc)
225 ddev->curr_protocol = 0;
226}
227
228static int digital_in_send_psl_req(struct nfc_digital_dev *ddev,
229 struct nfc_target *target)
230{
231 struct sk_buff *skb;
232 struct digital_psl_req *psl_req;
b15829ba 233 int rc;
b08147cb 234 u8 payload_size, payload_bits;
dddb3da0
MG		 235
236 skb = digital_skb_alloc(ddev, sizeof(*psl_req));
237 if (!skb)
238 return -ENOMEM;
239
240 skb_put(skb, sizeof(*psl_req));
241
242 psl_req = (struct digital_psl_req *)skb->data;
243
244 psl_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
245 psl_req->cmd = DIGITAL_CMD_PSL_REQ;
246 psl_req->did = 0;
247 psl_req->brs = (0x2 << 3) | 0x2; /* 424F both directions */
b08147cb
MG		 248
249 payload_size = min(ddev->local_payload_max, ddev->remote_payload_max);
250 payload_bits = digital_payload_size_to_bits(payload_size);
251 psl_req->fsl = DIGITAL_PAYLOAD_BITS_TO_FSL(payload_bits);
252
253 ddev->local_payload_max = payload_size;
254 ddev->remote_payload_max = payload_size;
dddb3da0
MG		 255
256 digital_skb_push_dep_sod(ddev, skb);
257
258 ddev->skb_add_crc(skb);
259
b15829ba
MG		 260 rc = digital_in_send_cmd(ddev, skb, 500, digital_in_recv_psl_res,
261 target);
262 if (rc)
263 kfree_skb(skb);
264
265 return rc;
dddb3da0
MG		 266}
267
7d0911c0
TE		 268static void digital_in_recv_atr_res(struct nfc_digital_dev *ddev, void *arg,
269 struct sk_buff *resp)
270{
271 struct nfc_target *target = arg;
272 struct digital_atr_res *atr_res;
b08147cb 273 u8 gb_len, payload_bits;
7d0911c0
TE		 274 int rc;
275
276 if (IS_ERR(resp)) {
277 rc = PTR_ERR(resp);
278 resp = NULL;
279 goto exit;
280 }
281
282 rc = ddev->skb_check_crc(resp);
283 if (rc) {
284 PROTOCOL_ERR("14.4.1.6");
285 goto exit;
286 }
287
288 rc = digital_skb_pull_dep_sod(ddev, resp);
289 if (rc) {
290 PROTOCOL_ERR("14.4.1.2");
291 goto exit;
292 }
293
294 if (resp->len < sizeof(struct digital_atr_res)) {
295 rc = -EIO;
296 goto exit;
297 }
298
299 gb_len = resp->len - sizeof(struct digital_atr_res);
300
301 atr_res = (struct digital_atr_res *)resp->data;
302
b08147cb
MG		 303 payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_res->pp);
304 ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
305
306 if (!ddev->remote_payload_max) {
307 rc = -EINVAL;
308 goto exit;
309 }
310
7d0911c0
TE		 311 rc = nfc_set_remote_general_bytes(ddev->nfc_dev, atr_res->gb, gb_len);
312 if (rc)
313 goto exit;
314
dddb3da0
MG		 315 if ((ddev->protocols & NFC_PROTO_FELICA_MASK) &&
316 (ddev->curr_rf_tech != NFC_DIGITAL_RF_TECH_424F)) {
317 rc = digital_in_send_psl_req(ddev, target);
318 if (!rc)
319 goto exit;
320 }
321
7d0911c0
TE		 322 rc = nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
323 NFC_RF_INITIATOR);
324
325 ddev->curr_nfc_dep_pni = 0;
326
327exit:
328 dev_kfree_skb(resp);
329
330 if (rc)
331 ddev->curr_protocol = 0;
332}
333
334int digital_in_send_atr_req(struct nfc_digital_dev *ddev,
335 struct nfc_target *target, __u8 comm_mode, __u8 *gb,
336 size_t gb_len)
337{
338 struct sk_buff *skb;
339 struct digital_atr_req *atr_req;
340 uint size;
b15829ba 341 int rc;
b08147cb 342 u8 payload_bits;
7d0911c0
TE		 343
344 size = DIGITAL_ATR_REQ_MIN_SIZE + gb_len;
345
346 if (size > DIGITAL_ATR_REQ_MAX_SIZE) {
347 PROTOCOL_ERR("14.6.1.1");
348 return -EINVAL;
349 }
350
351 skb = digital_skb_alloc(ddev, size);
352 if (!skb)
353 return -ENOMEM;
354
355 skb_put(skb, sizeof(struct digital_atr_req));
356
357 atr_req = (struct digital_atr_req *)skb->data;
358 memset(atr_req, 0, sizeof(struct digital_atr_req));
359
360 atr_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
361 atr_req->cmd = DIGITAL_CMD_ATR_REQ;
362 if (target->nfcid2_len)
4f319e32 363 memcpy(atr_req->nfcid3, target->nfcid2, NFC_NFCID2_MAXSIZE);
7d0911c0 364 else
4f319e32 365 get_random_bytes(atr_req->nfcid3, NFC_NFCID3_MAXSIZE);
7d0911c0
TE		 366
367 atr_req->did = 0;
368 atr_req->bs = 0;
369 atr_req->br = 0;
370
b08147cb
MG		 371 ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX;
372 payload_bits = digital_payload_size_to_bits(ddev->local_payload_max);
373 atr_req->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits);
7d0911c0
TE		 374
375 if (gb_len) {
376 atr_req->pp |= DIGITAL_GB_BIT;
377 memcpy(skb_put(skb, gb_len), gb, gb_len);
378 }
379
380 digital_skb_push_dep_sod(ddev, skb);
381
382 ddev->skb_add_crc(skb);
383
b15829ba
MG		 384 rc = digital_in_send_cmd(ddev, skb, 500, digital_in_recv_atr_res,
385 target);
386 if (rc)
387 kfree_skb(skb);
388
389 return rc;
7d0911c0
TE		 390}
391
392static int digital_in_send_rtox(struct nfc_digital_dev *ddev,
393 struct digital_data_exch *data_exch, u8 rtox)
394{
395 struct digital_dep_req_res *dep_req;
396 struct sk_buff *skb;
397 int rc;
398
399 skb = digital_skb_alloc(ddev, 1);
400 if (!skb)
401 return -ENOMEM;
402
403 *skb_put(skb, 1) = rtox;
404
405 skb_push(skb, sizeof(struct digital_dep_req_res));
406
407 dep_req = (struct digital_dep_req_res *)skb->data;
408
409 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
410 dep_req->cmd = DIGITAL_CMD_DEP_REQ;
411 dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU |
412 DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT;
413
414 digital_skb_push_dep_sod(ddev, skb);
415
416 ddev->skb_add_crc(skb);
417
418 rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
419 data_exch);
b15829ba
MG		 420 if (rc)
421 kfree_skb(skb);
7d0911c0
TE		 422
423 return rc;
424}
425
426static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
427 struct sk_buff *resp)
428{
429 struct digital_data_exch *data_exch = arg;
430 struct digital_dep_req_res *dep_res;
431 u8 pfb;
432 uint size;
433 int rc;
434
435 if (IS_ERR(resp)) {
436 rc = PTR_ERR(resp);
437 resp = NULL;
438 goto exit;
439 }
440
441 rc = ddev->skb_check_crc(resp);
442 if (rc) {
443 PROTOCOL_ERR("14.4.1.6");
444 goto error;
445 }
446
447 rc = digital_skb_pull_dep_sod(ddev, resp);
448 if (rc) {
449 PROTOCOL_ERR("14.4.1.2");
450 goto exit;
451 }
452
b08147cb
MG		 453 if (resp->len > ddev->local_payload_max) {
454 rc = -EMSGSIZE;
455 goto exit;
456 }
457
6ce30668 458 size = sizeof(struct digital_dep_req_res);
7d0911c0
TE		 459 dep_res = (struct digital_dep_req_res *)resp->data;
460
6ce30668 461 if (resp->len < size || dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN ||
7d0911c0
TE		 462 dep_res->cmd != DIGITAL_CMD_DEP_RES) {
463 rc = -EIO;
464 goto error;
465 }
466
467 pfb = dep_res->pfb;
468
3bc3f88a
MG		 469 if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
470 PROTOCOL_ERR("14.8.2.1");
471 rc = -EIO;
472 goto error;
473 }
6ce30668 474
3e6b0de8
MG		 475 if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
476 rc = -EIO;
477 goto exit;
478 }
479
6ce30668
MG		 480 if (size > resp->len) {
481 rc = -EIO;
482 goto error;
483 }
484
485 skb_pull(resp, size);
486
7d0911c0
TE		 487 switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
488 case DIGITAL_NFC_DEP_PFB_I_PDU:
489 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
490 PROTOCOL_ERR("14.12.3.3");
491 rc = -EIO;
492 goto error;
493 }
494
495 ddev->curr_nfc_dep_pni =
496 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
497 rc = 0;
498 break;
499
500 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
26042530 501 pr_err("Received a ACK/NACK PDU\n");
485fdc9b
MG		 502
503 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
504 PROTOCOL_ERR("14.12.3.3");
505 rc = -EIO;
506 goto exit;
507 }
508
509 ddev->curr_nfc_dep_pni =
510 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
511
512 rc = -EINVAL;
513 goto exit;
7d0911c0
TE		 514
515 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
516 if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) {
517 rc = -EINVAL;
518 goto error;
519 }
520
6ce30668 521 rc = digital_in_send_rtox(ddev, data_exch, resp->data[0]);
7d0911c0
TE		 522 if (rc)
523 goto error;
524
525 kfree_skb(resp);
526 return;
527 }
528
529 if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb)) {
26042530 530 pr_err("MI bit set. Chained PDU not supported\n");
7d0911c0
TE		 531 rc = -EIO;
532 goto error;
533 }
534
7d0911c0
TE		 535exit:
536 data_exch->cb(data_exch->cb_context, resp, rc);
537
538error:
539 kfree(data_exch);
540
541 if (rc)
542 kfree_skb(resp);
543}
544
545int digital_in_send_dep_req(struct nfc_digital_dev *ddev,
546 struct nfc_target *target, struct sk_buff *skb,
547 struct digital_data_exch *data_exch)
548{
549 struct digital_dep_req_res *dep_req;
550
551 skb_push(skb, sizeof(struct digital_dep_req_res));
552
b08147cb
MG		 553 if (skb->len > ddev->remote_payload_max)
554 return -EMSGSIZE;
555
7d0911c0
TE		 556 dep_req = (struct digital_dep_req_res *)skb->data;
557 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
558 dep_req->cmd = DIGITAL_CMD_DEP_REQ;
559 dep_req->pfb = ddev->curr_nfc_dep_pni;
560
561 digital_skb_push_dep_sod(ddev, skb);
562
563 ddev->skb_add_crc(skb);
564
565 return digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
566 data_exch);
567}
1c7a4c24 568
b711ad52
TE		 569static void digital_tg_set_rf_tech(struct nfc_digital_dev *ddev, u8 rf_tech)
570{
571 ddev->curr_rf_tech = rf_tech;
572
573 ddev->skb_add_crc = digital_skb_add_crc_none;
574 ddev->skb_check_crc = digital_skb_check_crc_none;
575
576 if (DIGITAL_DRV_CAPS_TG_CRC(ddev))
577 return;
578
579 switch (ddev->curr_rf_tech) {
580 case NFC_DIGITAL_RF_TECH_106A:
581 ddev->skb_add_crc = digital_skb_add_crc_a;
582 ddev->skb_check_crc = digital_skb_check_crc_a;
583 break;
584
585 case NFC_DIGITAL_RF_TECH_212F:
586 case NFC_DIGITAL_RF_TECH_424F:
587 ddev->skb_add_crc = digital_skb_add_crc_f;
588 ddev->skb_check_crc = digital_skb_check_crc_f;
589 break;
590
591 default:
592 break;
593 }
594}
595
1c7a4c24
TE		 596static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
597 struct sk_buff *resp)
598{
599 int rc;
600 struct digital_dep_req_res *dep_req;
6ce30668 601 u8 pfb;
1c7a4c24
TE		 602 size_t size;
603
604 if (IS_ERR(resp)) {
605 rc = PTR_ERR(resp);
606 resp = NULL;
607 goto exit;
608 }
609
610 rc = ddev->skb_check_crc(resp);
611 if (rc) {
612 PROTOCOL_ERR("14.4.1.6");
613 goto exit;
614 }
615
616 rc = digital_skb_pull_dep_sod(ddev, resp);
617 if (rc) {
618 PROTOCOL_ERR("14.4.1.2");
619 goto exit;
620 }
621
b08147cb
MG		 622 if (resp->len > ddev->local_payload_max) {
623 rc = -EMSGSIZE;
624 goto exit;
625 }
626
1c7a4c24
TE		 627 size = sizeof(struct digital_dep_req_res);
628 dep_req = (struct digital_dep_req_res *)resp->data;
629
630 if (resp->len < size || dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
631 dep_req->cmd != DIGITAL_CMD_DEP_REQ) {
632 rc = -EIO;
633 goto exit;
634 }
635
6ce30668
MG		 636 pfb = dep_req->pfb;
637
05afedcb
MG		 638 if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
639 if (ddev->did && (ddev->did == resp->data[3])) {
640 size++;
641 } else {
642 rc = -EIO;
643 goto exit;
644 }
645 } else if (ddev->did) {
646 rc = -EIO;
647 goto exit;
648 }
1c7a4c24 649
3e6b0de8
MG		 650 if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
651 rc = -EIO;
652 goto exit;
653 }
654
6ce30668 655 if (size > resp->len) {
1c7a4c24
TE		 656 rc = -EIO;
657 goto exit;
658 }
659
6ce30668
MG		 660 skb_pull(resp, size);
661
662 switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
1c7a4c24 663 case DIGITAL_NFC_DEP_PFB_I_PDU:
26042530 664 pr_debug("DIGITAL_NFC_DEP_PFB_I_PDU\n");
485fdc9b
MG		 665
666 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
667 PROTOCOL_ERR("14.12.3.4");
668 rc = -EIO;
669 goto exit;
670 }
671
672 rc = 0;
1c7a4c24
TE		 673 break;
674 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
485fdc9b
MG		 675 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
676 PROTOCOL_ERR("14.12.3.4");
677 rc = -EIO;
678 goto exit;
679 }
680
26042530 681 pr_err("Received a ACK/NACK PDU\n");
1c7a4c24
TE		 682 rc = -EINVAL;
683 goto exit;
1c7a4c24 684 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
26042530 685 pr_err("Received a SUPERVISOR PDU\n");
1c7a4c24
TE		 686 rc = -EINVAL;
687 goto exit;
1c7a4c24
TE		 688 }
689
1c7a4c24
TE		 690 rc = nfc_tm_data_received(ddev->nfc_dev, resp);
691
692exit:
693 if (rc)
694 kfree_skb(resp);
695}
696
697int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb)
698{
699 struct digital_dep_req_res *dep_res;
700
701 skb_push(skb, sizeof(struct digital_dep_req_res));
b08147cb
MG		 702
703 if (skb->len > ddev->remote_payload_max)
704 return -EMSGSIZE;
705
1c7a4c24
TE		 706 dep_res = (struct digital_dep_req_res *)skb->data;
707
708 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
709 dep_res->cmd = DIGITAL_CMD_DEP_RES;
710 dep_res->pfb = ddev->curr_nfc_dep_pni;
711
05afedcb
MG		 712 if (ddev->did) {
713 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
714
715 memcpy(skb_put(skb, sizeof(ddev->did)), &ddev->did,
716 sizeof(ddev->did));
717 }
718
485fdc9b
MG		 719 ddev->curr_nfc_dep_pni =
720 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
721
1c7a4c24
TE		 722 digital_skb_push_dep_sod(ddev, skb);
723
724 ddev->skb_add_crc(skb);
725
726 return digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
727 NULL);
728}
729
730static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev,
731 void *arg, struct sk_buff *resp)
732{
67af1d7a 733 u8 rf_tech = (unsigned long)arg;
1c7a4c24
TE		 734
735 if (IS_ERR(resp))
736 return;
737
b711ad52
TE		 738 digital_tg_set_rf_tech(ddev, rf_tech);
739
1c7a4c24
TE		 740 digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
741
742 digital_tg_listen(ddev, 1500, digital_tg_recv_dep_req, NULL);
743
744 dev_kfree_skb(resp);
745}
746
747static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did,
748 u8 rf_tech)
749{
750 struct digital_psl_res *psl_res;
751 struct sk_buff *skb;
752 int rc;
753
754 skb = digital_skb_alloc(ddev, sizeof(struct digital_psl_res));
755 if (!skb)
756 return -ENOMEM;
757
758 skb_put(skb, sizeof(struct digital_psl_res));
759
760 psl_res = (struct digital_psl_res *)skb->data;
761
762 psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
763 psl_res->cmd = DIGITAL_CMD_PSL_RES;
764 psl_res->did = did;
765
766 digital_skb_push_dep_sod(ddev, skb);
767
768 ddev->skb_add_crc(skb);
769
485fdc9b
MG		 770 ddev->curr_nfc_dep_pni = 0;
771
1c7a4c24 772 rc = digital_tg_send_cmd(ddev, skb, 0, digital_tg_send_psl_res_complete,
67af1d7a 773 (void *)(unsigned long)rf_tech);
1c7a4c24
TE		 774 if (rc)
775 kfree_skb(skb);
776
777 return rc;
778}
779
780static void digital_tg_recv_psl_req(struct nfc_digital_dev *ddev, void *arg,
781 struct sk_buff *resp)
782{
783 int rc;
784 struct digital_psl_req *psl_req;
785 u8 rf_tech;
b08147cb 786 u8 dsi, payload_size, payload_bits;
1c7a4c24
TE		 787
788 if (IS_ERR(resp)) {
789 rc = PTR_ERR(resp);
790 resp = NULL;
791 goto exit;
792 }
793
794 rc = ddev->skb_check_crc(resp);
795 if (rc) {
796 PROTOCOL_ERR("14.4.1.6");
797 goto exit;
798 }
799
800 rc = digital_skb_pull_dep_sod(ddev, resp);
801 if (rc) {
802 PROTOCOL_ERR("14.4.1.2");
803 goto exit;
804 }
805
806 psl_req = (struct digital_psl_req *)resp->data;
807
808 if (resp->len != sizeof(struct digital_psl_req) ||
809 psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
810 psl_req->cmd != DIGITAL_CMD_PSL_REQ) {
811 rc = -EIO;
812 goto exit;
813 }
814
815 dsi = (psl_req->brs >> 3) & 0x07;
816 switch (dsi) {
817 case 0:
818 rf_tech = NFC_DIGITAL_RF_TECH_106A;
819 break;
820 case 1:
821 rf_tech = NFC_DIGITAL_RF_TECH_212F;
822 break;
823 case 2:
824 rf_tech = NFC_DIGITAL_RF_TECH_424F;
825 break;
826 default:
77d84ff8 827 pr_err("Unsupported dsi value %d\n", dsi);
1c7a4c24
TE		 828 goto exit;
829 }
830
b08147cb
MG		 831 payload_bits = DIGITAL_PAYLOAD_FSL_TO_BITS(psl_req->fsl);
832 payload_size = digital_payload_bits_to_size(payload_bits);
833
834 if (!payload_size || (payload_size > min(ddev->local_payload_max,
835 ddev->remote_payload_max))) {
836 rc = -EINVAL;
837 goto exit;
838 }
839
840 ddev->local_payload_max = payload_size;
841 ddev->remote_payload_max = payload_size;
842
1c7a4c24
TE		 843 rc = digital_tg_send_psl_res(ddev, psl_req->did, rf_tech);
844
845exit:
846 kfree_skb(resp);
847}
848
849static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev,
850 void *arg, struct sk_buff *resp)
851{
852 int offset;
853
854 if (IS_ERR(resp)) {
855 digital_poll_next_tech(ddev);
856 return;
857 }
858
859 offset = 2;
860 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB)
861 offset++;
862
863 if (resp->data[offset] == DIGITAL_CMD_PSL_REQ)
864 digital_tg_recv_psl_req(ddev, arg, resp);
865 else
866 digital_tg_recv_dep_req(ddev, arg, resp);
867}
868
869static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev,
870 struct digital_atr_req *atr_req)
871{
872 struct digital_atr_res *atr_res;
873 struct sk_buff *skb;
b08147cb 874 u8 *gb, payload_bits;
1c7a4c24
TE		 875 size_t gb_len;
876 int rc;
877
878 gb = nfc_get_local_general_bytes(ddev->nfc_dev, &gb_len);
879 if (!gb)
880 gb_len = 0;
881
882 skb = digital_skb_alloc(ddev, sizeof(struct digital_atr_res) + gb_len);
883 if (!skb)
884 return -ENOMEM;
885
886 skb_put(skb, sizeof(struct digital_atr_res));
887 atr_res = (struct digital_atr_res *)skb->data;
888
889 memset(atr_res, 0, sizeof(struct digital_atr_res));
890
891 atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
892 atr_res->cmd = DIGITAL_CMD_ATR_RES;
893 memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3));
894 atr_res->to = 8;
b08147cb
MG		 895
896 ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX;
897 payload_bits = digital_payload_size_to_bits(ddev->local_payload_max);
898 atr_res->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits);
899
1c7a4c24
TE		 900 if (gb_len) {
901 skb_put(skb, gb_len);
902
903 atr_res->pp |= DIGITAL_GB_BIT;
904 memcpy(atr_res->gb, gb, gb_len);
905 }
906
907 digital_skb_push_dep_sod(ddev, skb);
908
909 ddev->skb_add_crc(skb);
910
485fdc9b
MG		 911 ddev->curr_nfc_dep_pni = 0;
912
1c7a4c24
TE		 913 rc = digital_tg_send_cmd(ddev, skb, 999,
914 digital_tg_send_atr_res_complete, NULL);
b15829ba 915 if (rc)
1c7a4c24 916 kfree_skb(skb);
1c7a4c24
TE		 917
918 return rc;
919}
920
921void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg,
922 struct sk_buff *resp)
923{
924 int rc;
925 struct digital_atr_req *atr_req;
926 size_t gb_len, min_size;
b08147cb 927 u8 poll_tech_count, payload_bits;
1c7a4c24
TE		 928
929 if (IS_ERR(resp)) {
930 rc = PTR_ERR(resp);
931 resp = NULL;
932 goto exit;
933 }
934
935 if (!resp->len) {
936 rc = -EIO;
937 goto exit;
938 }
939
940 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) {
941 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2;
b711ad52 942 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_106A);
1c7a4c24
TE		 943 } else {
944 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1;
b711ad52 945 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_212F);
1c7a4c24
TE		 946 }
947
948 if (resp->len < min_size) {
949 rc = -EIO;
950 goto exit;
951 }
952
48e10445 953 ddev->curr_protocol = NFC_PROTO_NFC_DEP_MASK;
1c7a4c24
TE		 954
955 rc = ddev->skb_check_crc(resp);
956 if (rc) {
957 PROTOCOL_ERR("14.4.1.6");
958 goto exit;
959 }
960
961 rc = digital_skb_pull_dep_sod(ddev, resp);
962 if (rc) {
963 PROTOCOL_ERR("14.4.1.2");
964 goto exit;
965 }
966
967 atr_req = (struct digital_atr_req *)resp->data;
968
969 if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
05afedcb
MG		 970 atr_req->cmd != DIGITAL_CMD_ATR_REQ ||
971 atr_req->did > DIGITAL_DID_MAX) {
1c7a4c24
TE		 972 rc = -EINVAL;
973 goto exit;
974 }
975
b08147cb
MG		 976 payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_req->pp);
977 ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
978
979 if (!ddev->remote_payload_max) {
980 rc = -EINVAL;
981 goto exit;
982 }
983
05afedcb
MG		 984 ddev->did = atr_req->did;
985
1c7a4c24
TE		 986 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
987 NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED);
988 if (rc)
989 goto exit;
990
991 rc = digital_tg_send_atr_res(ddev, atr_req);
992 if (rc)
993 goto exit;
994
995 gb_len = resp->len - sizeof(struct digital_atr_req);
0529a7ad
MG		 996
997 poll_tech_count = ddev->poll_tech_count;
998 ddev->poll_tech_count = 0;
999
1c7a4c24
TE		 1000 rc = nfc_tm_activated(ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
1001 NFC_COMM_PASSIVE, atr_req->gb, gb_len);
0529a7ad
MG		 1002 if (rc) {
1003 ddev->poll_tech_count = poll_tech_count;
1c7a4c24 1004 goto exit;
0529a7ad 1005 }
1c7a4c24
TE		 1006
1007 rc = 0;
1008exit:
1009 if (rc)
1010 digital_poll_next_tech(ddev);
1011
1012 dev_kfree_skb(resp);
1013}
Linux kernel - Deliverables
This page took 0.116825 seconds and 5 git commands to generate.