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