aboutsummaryrefslogtreecommitdiffstats
path: root/net/nfc
diff options
context:
space:
mode:
authorThierry Escande <thierry.escande@linux.intel.com>2013-09-19 11:55:30 -0400
committerSamuel Ortiz <sameo@linux.intel.com>2013-09-24 20:02:28 -0400
commit1c7a4c24fbfd99442cc6e14dc80fcb00f118e8b8 (patch)
treed8115482922f1d4b5c7da4a6aa76faca7f77c032 /net/nfc
parent7d0911c02fa2a448a28d7844d2a0c439ff8397b1 (diff)
NFC Digital: Add target NFC-DEP support
This adds support for NFC-DEP target mode for NFC-A and NFC-F technologies. If the driver provides it, the stack uses an automatic mode for technology detection and automatic anti-collision. Otherwise the stack tries to use non-automatic synchronization and listens for SENS_REQ and SENSF_REQ commands. The detection, activation, and data exchange procedures work exactly the same way as in initiator mode, as described in the previous commits, except that the digital stack waits for commands and sends responses back to the peer device. Signed-off-by: Thierry Escande <thierry.escande@linux.intel.com> Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
Diffstat (limited to 'net/nfc')
-rw-r--r--net/nfc/digital.h39
-rw-r--r--net/nfc/digital_core.c81
-rw-r--r--net/nfc/digital_dep.c346
-rw-r--r--net/nfc/digital_technology.c296
4 files changed, 755 insertions, 7 deletions
diff --git a/net/nfc/digital.h b/net/nfc/digital.h
index 5254a872522b..586075a3feed 100644
--- a/net/nfc/digital.h
+++ b/net/nfc/digital.h
@@ -56,8 +56,9 @@ struct sk_buff *digital_skb_alloc(struct nfc_digital_dev *ddev,
56 unsigned int len); 56 unsigned int len);
57 57
58int digital_send_cmd(struct nfc_digital_dev *ddev, u8 cmd_type, 58int digital_send_cmd(struct nfc_digital_dev *ddev, u8 cmd_type,
59 struct sk_buff *skb, u16 timeout, 59 struct sk_buff *skb, struct digital_tg_mdaa_params *params,
60 nfc_digital_cmd_complete_t cmd_cb, void *cb_context); 60 u16 timeout, nfc_digital_cmd_complete_t cmd_cb,
61 void *cb_context);
61 62
62int digital_in_configure_hw(struct nfc_digital_dev *ddev, int type, int param); 63int digital_in_configure_hw(struct nfc_digital_dev *ddev, int type, int param);
63static inline int digital_in_send_cmd(struct nfc_digital_dev *ddev, 64static inline int digital_in_send_cmd(struct nfc_digital_dev *ddev,
@@ -65,8 +66,8 @@ static inline int digital_in_send_cmd(struct nfc_digital_dev *ddev,
65 nfc_digital_cmd_complete_t cmd_cb, 66 nfc_digital_cmd_complete_t cmd_cb,
66 void *cb_context) 67 void *cb_context)
67{ 68{
68 return digital_send_cmd(ddev, DIGITAL_CMD_IN_SEND, skb, timeout, cmd_cb, 69 return digital_send_cmd(ddev, DIGITAL_CMD_IN_SEND, skb, NULL, timeout,
69 cb_context); 70 cmd_cb, cb_context);
70} 71}
71 72
72void digital_poll_next_tech(struct nfc_digital_dev *ddev); 73void digital_poll_next_tech(struct nfc_digital_dev *ddev);
@@ -86,6 +87,36 @@ int digital_in_send_dep_req(struct nfc_digital_dev *ddev,
86 struct nfc_target *target, struct sk_buff *skb, 87 struct nfc_target *target, struct sk_buff *skb,
87 struct digital_data_exch *data_exch); 88 struct digital_data_exch *data_exch);
88 89
90int digital_tg_configure_hw(struct nfc_digital_dev *ddev, int type, int param);
91static inline int digital_tg_send_cmd(struct nfc_digital_dev *ddev,
92 struct sk_buff *skb, u16 timeout,
93 nfc_digital_cmd_complete_t cmd_cb, void *cb_context)
94{
95 return digital_send_cmd(ddev, DIGITAL_CMD_TG_SEND, skb, NULL, timeout,
96 cmd_cb, cb_context);
97}
98
99void digital_tg_recv_sens_req(struct nfc_digital_dev *ddev, void *arg,
100 struct sk_buff *resp);
101
102void digital_tg_recv_sensf_req(struct nfc_digital_dev *ddev, void *arg,
103 struct sk_buff *resp);
104
105static inline int digital_tg_listen(struct nfc_digital_dev *ddev, u16 timeout,
106 nfc_digital_cmd_complete_t cb, void *arg)
107{
108 return digital_send_cmd(ddev, DIGITAL_CMD_TG_LISTEN, NULL, NULL,
109 timeout, cb, arg);
110}
111
112void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg,
113 struct sk_buff *resp);
114
115int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb);
116
117int digital_tg_listen_nfca(struct nfc_digital_dev *ddev, u8 rf_tech);
118int digital_tg_listen_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech);
119
89typedef u16 (*crc_func_t)(u16, const u8 *, size_t); 120typedef u16 (*crc_func_t)(u16, const u8 *, size_t);
90 121
91#define CRC_A_INIT 0x6363 122#define CRC_A_INIT 0x6363
diff --git a/net/nfc/digital_core.c b/net/nfc/digital_core.c
index dccfcccf6998..66151fc5d990 100644
--- a/net/nfc/digital_core.c
+++ b/net/nfc/digital_core.c
@@ -32,6 +32,7 @@ struct digital_cmd {
32 u16 timeout; 32 u16 timeout;
33 struct sk_buff *req; 33 struct sk_buff *req;
34 struct sk_buff *resp; 34 struct sk_buff *resp;
35 struct digital_tg_mdaa_params *mdaa_params;
35 36
36 nfc_digital_cmd_complete_t cmd_cb; 37 nfc_digital_cmd_complete_t cmd_cb;
37 void *cb_context; 38 void *cb_context;
@@ -131,6 +132,7 @@ static void digital_wq_cmd_complete(struct work_struct *work)
131 132
132 cmd->cmd_cb(ddev, cmd->cb_context, cmd->resp); 133 cmd->cmd_cb(ddev, cmd->cb_context, cmd->resp);
133 134
135 kfree(cmd->mdaa_params);
134 kfree(cmd); 136 kfree(cmd);
135 137
136 schedule_work(&ddev->cmd_work); 138 schedule_work(&ddev->cmd_work);
@@ -150,6 +152,7 @@ static void digital_wq_cmd(struct work_struct *work)
150{ 152{
151 int rc; 153 int rc;
152 struct digital_cmd *cmd; 154 struct digital_cmd *cmd;
155 struct digital_tg_mdaa_params *params;
153 struct nfc_digital_dev *ddev = container_of(work, 156 struct nfc_digital_dev *ddev = container_of(work,
154 struct nfc_digital_dev, 157 struct nfc_digital_dev,
155 cmd_work); 158 cmd_work);
@@ -174,6 +177,24 @@ static void digital_wq_cmd(struct work_struct *work)
174 rc = ddev->ops->in_send_cmd(ddev, cmd->req, cmd->timeout, 177 rc = ddev->ops->in_send_cmd(ddev, cmd->req, cmd->timeout,
175 digital_send_cmd_complete, cmd); 178 digital_send_cmd_complete, cmd);
176 break; 179 break;
180
181 case DIGITAL_CMD_TG_SEND:
182 rc = ddev->ops->tg_send_cmd(ddev, cmd->req, cmd->timeout,
183 digital_send_cmd_complete, cmd);
184 break;
185
186 case DIGITAL_CMD_TG_LISTEN:
187 rc = ddev->ops->tg_listen(ddev, cmd->timeout,
188 digital_send_cmd_complete, cmd);
189 break;
190
191 case DIGITAL_CMD_TG_LISTEN_MDAA:
192 params = cmd->mdaa_params;
193
194 rc = ddev->ops->tg_listen_mdaa(ddev, params, cmd->timeout,
195 digital_send_cmd_complete, cmd);
196 break;
197
177 default: 198 default:
178 PR_ERR("Unknown cmd type %d", cmd->type); 199 PR_ERR("Unknown cmd type %d", cmd->type);
179 return; 200 return;
@@ -189,14 +210,16 @@ static void digital_wq_cmd(struct work_struct *work)
189 mutex_unlock(&ddev->cmd_lock); 210 mutex_unlock(&ddev->cmd_lock);
190 211
191 kfree_skb(cmd->req); 212 kfree_skb(cmd->req);
213 kfree(cmd->mdaa_params);
192 kfree(cmd); 214 kfree(cmd);
193 215
194 schedule_work(&ddev->cmd_work); 216 schedule_work(&ddev->cmd_work);
195} 217}
196 218
197int digital_send_cmd(struct nfc_digital_dev *ddev, u8 cmd_type, 219int digital_send_cmd(struct nfc_digital_dev *ddev, u8 cmd_type,
198 struct sk_buff *skb, u16 timeout, 220 struct sk_buff *skb, struct digital_tg_mdaa_params *params,
199 nfc_digital_cmd_complete_t cmd_cb, void *cb_context) 221 u16 timeout, nfc_digital_cmd_complete_t cmd_cb,
222 void *cb_context)
200{ 223{
201 struct digital_cmd *cmd; 224 struct digital_cmd *cmd;
202 225
@@ -207,6 +230,7 @@ int digital_send_cmd(struct nfc_digital_dev *ddev, u8 cmd_type,
207 cmd->type = cmd_type; 230 cmd->type = cmd_type;
208 cmd->timeout = timeout; 231 cmd->timeout = timeout;
209 cmd->req = skb; 232 cmd->req = skb;
233 cmd->mdaa_params = params;
210 cmd->cmd_cb = cmd_cb; 234 cmd->cmd_cb = cmd_cb;
211 cmd->cb_context = cb_context; 235 cmd->cb_context = cb_context;
212 INIT_LIST_HEAD(&cmd->queue); 236 INIT_LIST_HEAD(&cmd->queue);
@@ -231,6 +255,38 @@ int digital_in_configure_hw(struct nfc_digital_dev *ddev, int type, int param)
231 return rc; 255 return rc;
232} 256}
233 257
258int digital_tg_configure_hw(struct nfc_digital_dev *ddev, int type, int param)
259{
260 int rc;
261
262 rc = ddev->ops->tg_configure_hw(ddev, type, param);
263 if (rc)
264 PR_ERR("tg_configure_hw failed: %d", rc);
265
266 return rc;
267}
268
269static int digital_tg_listen_mdaa(struct nfc_digital_dev *ddev, u8 rf_tech)
270{
271 struct digital_tg_mdaa_params *params;
272
273 params = kzalloc(sizeof(struct digital_tg_mdaa_params), GFP_KERNEL);
274 if (!params)
275 return -ENOMEM;
276
277 params->sens_res = DIGITAL_SENS_RES_NFC_DEP;
278 get_random_bytes(params->nfcid1, sizeof(params->nfcid1));
279 params->sel_res = DIGITAL_SEL_RES_NFC_DEP;
280
281 params->nfcid2[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1;
282 params->nfcid2[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2;
283 get_random_bytes(params->nfcid2 + 2, NFC_NFCID2_MAXSIZE - 2);
284 params->sc = DIGITAL_SENSF_FELICA_SC;
285
286 return digital_send_cmd(ddev, DIGITAL_CMD_TG_LISTEN_MDAA, NULL, params,
287 500, digital_tg_recv_atr_req, NULL);
288}
289
234int digital_target_found(struct nfc_digital_dev *ddev, 290int digital_target_found(struct nfc_digital_dev *ddev,
235 struct nfc_target *target, u8 protocol) 291 struct nfc_target *target, u8 protocol)
236{ 292{
@@ -412,6 +468,22 @@ static int digital_start_poll(struct nfc_dev *nfc_dev, __u32 im_protocols,
412 digital_in_send_sensf_req); 468 digital_in_send_sensf_req);
413 } 469 }
414 470
471 if (tm_protocols & NFC_PROTO_NFC_DEP_MASK) {
472 if (ddev->ops->tg_listen_mdaa) {
473 digital_add_poll_tech(ddev, 0,
474 digital_tg_listen_mdaa);
475 } else {
476 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_106A,
477 digital_tg_listen_nfca);
478
479 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_212F,
480 digital_tg_listen_nfcf);
481
482 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_424F,
483 digital_tg_listen_nfcf);
484 }
485 }
486
415 if (!ddev->poll_tech_count) { 487 if (!ddev->poll_tech_count) {
416 PR_ERR("Unsupported protocols: im=0x%x, tm=0x%x", 488 PR_ERR("Unsupported protocols: im=0x%x, tm=0x%x",
417 matching_im_protocols, matching_tm_protocols); 489 matching_im_protocols, matching_tm_protocols);
@@ -496,7 +568,9 @@ static void digital_deactivate_target(struct nfc_dev *nfc_dev,
496 568
497static int digital_tg_send(struct nfc_dev *dev, struct sk_buff *skb) 569static int digital_tg_send(struct nfc_dev *dev, struct sk_buff *skb)
498{ 570{
499 return -EOPNOTSUPP; 571 struct nfc_digital_dev *ddev = nfc_get_drvdata(dev);
572
573 return digital_tg_send_dep_res(ddev, skb);
500} 574}
501 575
502static void digital_in_send_complete(struct nfc_digital_dev *ddev, void *arg, 576static void digital_in_send_complete(struct nfc_digital_dev *ddev, void *arg,
@@ -654,6 +728,7 @@ void nfc_digital_unregister_device(struct nfc_digital_dev *ddev)
654 728
655 list_for_each_entry_safe(cmd, n, &ddev->cmd_queue, queue) { 729 list_for_each_entry_safe(cmd, n, &ddev->cmd_queue, queue) {
656 list_del(&cmd->queue); 730 list_del(&cmd->queue);
731 kfree(cmd->mdaa_params);
657 kfree(cmd); 732 kfree(cmd);
658 } 733 }
659} 734}
diff --git a/net/nfc/digital_dep.c b/net/nfc/digital_dep.c
index be984c4204d2..810d00c9cd5d 100644
--- a/net/nfc/digital_dep.c
+++ b/net/nfc/digital_dep.c
@@ -379,3 +379,349 @@ int digital_in_send_dep_req(struct nfc_digital_dev *ddev,
379 return digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res, 379 return digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
380 data_exch); 380 data_exch);
381} 381}
382
383static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
384 struct sk_buff *resp)
385{
386 int rc;
387 struct digital_dep_req_res *dep_req;
388 size_t size;
389
390 if (IS_ERR(resp)) {
391 rc = PTR_ERR(resp);
392 resp = NULL;
393 goto exit;
394 }
395
396 rc = ddev->skb_check_crc(resp);
397 if (rc) {
398 PROTOCOL_ERR("14.4.1.6");
399 goto exit;
400 }
401
402 rc = digital_skb_pull_dep_sod(ddev, resp);
403 if (rc) {
404 PROTOCOL_ERR("14.4.1.2");
405 goto exit;
406 }
407
408 size = sizeof(struct digital_dep_req_res);
409 dep_req = (struct digital_dep_req_res *)resp->data;
410
411 if (resp->len < size || dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
412 dep_req->cmd != DIGITAL_CMD_DEP_REQ) {
413 rc = -EIO;
414 goto exit;
415 }
416
417 if (DIGITAL_NFC_DEP_DID_BIT_SET(dep_req->pfb))
418 size++;
419
420 if (resp->len < size) {
421 rc = -EIO;
422 goto exit;
423 }
424
425 switch (DIGITAL_NFC_DEP_PFB_TYPE(dep_req->pfb)) {
426 case DIGITAL_NFC_DEP_PFB_I_PDU:
427 PR_DBG("DIGITAL_NFC_DEP_PFB_I_PDU");
428 ddev->curr_nfc_dep_pni = DIGITAL_NFC_DEP_PFB_PNI(dep_req->pfb);
429 break;
430 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
431 PR_ERR("Received a ACK/NACK PDU");
432 rc = -EINVAL;
433 goto exit;
434 break;
435 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
436 PR_ERR("Received a SUPERVISOR PDU");
437 rc = -EINVAL;
438 goto exit;
439 break;
440 }
441
442 skb_pull(resp, size);
443
444 rc = nfc_tm_data_received(ddev->nfc_dev, resp);
445
446exit:
447 if (rc)
448 kfree_skb(resp);
449}
450
451int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb)
452{
453 struct digital_dep_req_res *dep_res;
454
455 skb_push(skb, sizeof(struct digital_dep_req_res));
456 dep_res = (struct digital_dep_req_res *)skb->data;
457
458 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
459 dep_res->cmd = DIGITAL_CMD_DEP_RES;
460 dep_res->pfb = ddev->curr_nfc_dep_pni;
461
462 digital_skb_push_dep_sod(ddev, skb);
463
464 ddev->skb_add_crc(skb);
465
466 return digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
467 NULL);
468}
469
470static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev,
471 void *arg, struct sk_buff *resp)
472{
473 u8 rf_tech = PTR_ERR(arg);
474
475 if (IS_ERR(resp))
476 return;
477
478 digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
479
480 digital_tg_listen(ddev, 1500, digital_tg_recv_dep_req, NULL);
481
482 dev_kfree_skb(resp);
483}
484
485static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did,
486 u8 rf_tech)
487{
488 struct digital_psl_res *psl_res;
489 struct sk_buff *skb;
490 int rc;
491
492 skb = digital_skb_alloc(ddev, sizeof(struct digital_psl_res));
493 if (!skb)
494 return -ENOMEM;
495
496 skb_put(skb, sizeof(struct digital_psl_res));
497
498 psl_res = (struct digital_psl_res *)skb->data;
499
500 psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
501 psl_res->cmd = DIGITAL_CMD_PSL_RES;
502 psl_res->did = did;
503
504 digital_skb_push_dep_sod(ddev, skb);
505
506 ddev->skb_add_crc(skb);
507
508 rc = digital_tg_send_cmd(ddev, skb, 0, digital_tg_send_psl_res_complete,
509 ERR_PTR(rf_tech));
510
511 if (rc)
512 kfree_skb(skb);
513
514 return rc;
515}
516
517static void digital_tg_recv_psl_req(struct nfc_digital_dev *ddev, void *arg,
518 struct sk_buff *resp)
519{
520 int rc;
521 struct digital_psl_req *psl_req;
522 u8 rf_tech;
523 u8 dsi;
524
525 if (IS_ERR(resp)) {
526 rc = PTR_ERR(resp);
527 resp = NULL;
528 goto exit;
529 }
530
531 rc = ddev->skb_check_crc(resp);
532 if (rc) {
533 PROTOCOL_ERR("14.4.1.6");
534 goto exit;
535 }
536
537 rc = digital_skb_pull_dep_sod(ddev, resp);
538 if (rc) {
539 PROTOCOL_ERR("14.4.1.2");
540 goto exit;
541 }
542
543 psl_req = (struct digital_psl_req *)resp->data;
544
545 if (resp->len != sizeof(struct digital_psl_req) ||
546 psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
547 psl_req->cmd != DIGITAL_CMD_PSL_REQ) {
548 rc = -EIO;
549 goto exit;
550 }
551
552 dsi = (psl_req->brs >> 3) & 0x07;
553 switch (dsi) {
554 case 0:
555 rf_tech = NFC_DIGITAL_RF_TECH_106A;
556 break;
557 case 1:
558 rf_tech = NFC_DIGITAL_RF_TECH_212F;
559 break;
560 case 2:
561 rf_tech = NFC_DIGITAL_RF_TECH_424F;
562 break;
563 default:
564 PR_ERR("Unsuported dsi value %d", dsi);
565 goto exit;
566 }
567
568 rc = digital_tg_send_psl_res(ddev, psl_req->did, rf_tech);
569
570exit:
571 kfree_skb(resp);
572}
573
574static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev,
575 void *arg, struct sk_buff *resp)
576{
577 int offset;
578
579 if (IS_ERR(resp)) {
580 digital_poll_next_tech(ddev);
581 return;
582 }
583
584 offset = 2;
585 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB)
586 offset++;
587
588 if (resp->data[offset] == DIGITAL_CMD_PSL_REQ)
589 digital_tg_recv_psl_req(ddev, arg, resp);
590 else
591 digital_tg_recv_dep_req(ddev, arg, resp);
592}
593
594static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev,
595 struct digital_atr_req *atr_req)
596{
597 struct digital_atr_res *atr_res;
598 struct sk_buff *skb;
599 u8 *gb;
600 size_t gb_len;
601 int rc;
602
603 gb = nfc_get_local_general_bytes(ddev->nfc_dev, &gb_len);
604 if (!gb)
605 gb_len = 0;
606
607 skb = digital_skb_alloc(ddev, sizeof(struct digital_atr_res) + gb_len);
608 if (!skb)
609 return -ENOMEM;
610
611 skb_put(skb, sizeof(struct digital_atr_res));
612 atr_res = (struct digital_atr_res *)skb->data;
613
614 memset(atr_res, 0, sizeof(struct digital_atr_res));
615
616 atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
617 atr_res->cmd = DIGITAL_CMD_ATR_RES;
618 memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3));
619 atr_res->to = 8;
620 atr_res->pp = DIGITAL_LR_BITS_PAYLOAD_SIZE_254B;
621 if (gb_len) {
622 skb_put(skb, gb_len);
623
624 atr_res->pp |= DIGITAL_GB_BIT;
625 memcpy(atr_res->gb, gb, gb_len);
626 }
627
628 digital_skb_push_dep_sod(ddev, skb);
629
630 ddev->skb_add_crc(skb);
631
632 rc = digital_tg_send_cmd(ddev, skb, 999,
633 digital_tg_send_atr_res_complete, NULL);
634 if (rc) {
635 kfree_skb(skb);
636 return rc;
637 }
638
639 return rc;
640}
641
642void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg,
643 struct sk_buff *resp)
644{
645 int rc;
646 struct digital_atr_req *atr_req;
647 size_t gb_len, min_size;
648
649 if (IS_ERR(resp)) {
650 rc = PTR_ERR(resp);
651 resp = NULL;
652 goto exit;
653 }
654
655 if (!resp->len) {
656 rc = -EIO;
657 goto exit;
658 }
659
660 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) {
661 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2;
662
663 ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_106A;
664 ddev->skb_add_crc = digital_skb_add_crc_a;
665 ddev->skb_check_crc = digital_skb_check_crc_a;
666 } else {
667 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1;
668
669 ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_212F;
670 ddev->skb_add_crc = digital_skb_add_crc_f;
671 ddev->skb_check_crc = digital_skb_check_crc_f;
672 }
673
674 if (resp->len < min_size) {
675 rc = -EIO;
676 goto exit;
677 }
678
679 if (DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
680 ddev->skb_add_crc = digital_skb_add_crc_none;
681 ddev->skb_check_crc = digital_skb_check_crc_none;
682 }
683
684 rc = ddev->skb_check_crc(resp);
685 if (rc) {
686 PROTOCOL_ERR("14.4.1.6");
687 goto exit;
688 }
689
690 rc = digital_skb_pull_dep_sod(ddev, resp);
691 if (rc) {
692 PROTOCOL_ERR("14.4.1.2");
693 goto exit;
694 }
695
696 atr_req = (struct digital_atr_req *)resp->data;
697
698 if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
699 atr_req->cmd != DIGITAL_CMD_ATR_REQ) {
700 rc = -EINVAL;
701 goto exit;
702 }
703
704 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
705 NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED);
706 if (rc)
707 goto exit;
708
709 rc = digital_tg_send_atr_res(ddev, atr_req);
710 if (rc)
711 goto exit;
712
713 gb_len = resp->len - sizeof(struct digital_atr_req);
714 rc = nfc_tm_activated(ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
715 NFC_COMM_PASSIVE, atr_req->gb, gb_len);
716 if (rc)
717 goto exit;
718
719 ddev->poll_tech_count = 0;
720
721 rc = 0;
722exit:
723 if (rc)
724 digital_poll_next_tech(ddev);
725
726 dev_kfree_skb(resp);
727}
diff --git a/net/nfc/digital_technology.c b/net/nfc/digital_technology.c
index 0c28f600fd1c..564735fbbd8f 100644
--- a/net/nfc/digital_technology.c
+++ b/net/nfc/digital_technology.c
@@ -475,3 +475,299 @@ int digital_in_send_sensf_req(struct nfc_digital_dev *ddev, u8 rf_tech)
475 475
476 return rc; 476 return rc;
477} 477}
478
479static int digital_tg_send_sel_res(struct nfc_digital_dev *ddev)
480{
481 struct sk_buff *skb;
482 int rc;
483
484 skb = digital_skb_alloc(ddev, 1);
485 if (!skb)
486 return -ENOMEM;
487
488 *skb_put(skb, 1) = DIGITAL_SEL_RES_NFC_DEP;
489
490 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev))
491 digital_skb_add_crc_a(skb);
492
493 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_atr_req,
494 NULL);
495 if (rc)
496 kfree_skb(skb);
497
498 return rc;
499}
500
501static void digital_tg_recv_sel_req(struct nfc_digital_dev *ddev, void *arg,
502 struct sk_buff *resp)
503{
504 int rc;
505
506 if (IS_ERR(resp)) {
507 rc = PTR_ERR(resp);
508 resp = NULL;
509 goto exit;
510 }
511
512 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
513 rc = digital_skb_check_crc_a(resp);
514 if (rc) {
515 PROTOCOL_ERR("4.4.1.3");
516 goto exit;
517 }
518 }
519
520 /* Silently ignore SEL_REQ content and send a SEL_RES for NFC-DEP */
521
522 rc = digital_tg_send_sel_res(ddev);
523
524exit:
525 if (rc)
526 digital_poll_next_tech(ddev);
527
528 dev_kfree_skb(resp);
529}
530
531static int digital_tg_send_sdd_res(struct nfc_digital_dev *ddev)
532{
533 struct sk_buff *skb;
534 struct digital_sdd_res *sdd_res;
535 int rc, i;
536
537 skb = digital_skb_alloc(ddev, sizeof(struct digital_sdd_res));
538 if (!skb)
539 return -ENOMEM;
540
541 skb_put(skb, sizeof(struct digital_sdd_res));
542 sdd_res = (struct digital_sdd_res *)skb->data;
543
544 sdd_res->nfcid1[0] = 0x08;
545 get_random_bytes(sdd_res->nfcid1 + 1, 3);
546
547 sdd_res->bcc = 0;
548 for (i = 0; i < 4; i++)
549 sdd_res->bcc ^= sdd_res->nfcid1[i];
550
551 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sel_req,
552 NULL);
553 if (rc)
554 kfree_skb(skb);
555
556 return rc;
557}
558
559static void digital_tg_recv_sdd_req(struct nfc_digital_dev *ddev, void *arg,
560 struct sk_buff *resp)
561{
562 u8 *sdd_req;
563 int rc;
564
565 if (IS_ERR(resp)) {
566 rc = PTR_ERR(resp);
567 resp = NULL;
568 goto exit;
569 }
570
571 sdd_req = resp->data;
572
573 if (resp->len < 2 || sdd_req[0] != DIGITAL_CMD_SEL_REQ_CL1 ||
574 sdd_req[1] != DIGITAL_SDD_REQ_SEL_PAR) {
575 rc = -EINVAL;
576 goto exit;
577 }
578
579 rc = digital_tg_send_sdd_res(ddev);
580
581exit:
582 if (rc)
583 digital_poll_next_tech(ddev);
584
585 dev_kfree_skb(resp);
586}
587
588static int digital_tg_send_sens_res(struct nfc_digital_dev *ddev)
589{
590 struct sk_buff *skb;
591 u8 *sens_res;
592 int rc;
593
594 skb = digital_skb_alloc(ddev, 2);
595 if (!skb)
596 return -ENOMEM;
597
598 sens_res = skb_put(skb, 2);
599
600 sens_res[0] = (DIGITAL_SENS_RES_NFC_DEP >> 8) & 0xFF;
601 sens_res[1] = DIGITAL_SENS_RES_NFC_DEP & 0xFF;
602
603 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sdd_req,
604 NULL);
605 if (rc)
606 kfree_skb(skb);
607
608 return rc;
609}
610
611void digital_tg_recv_sens_req(struct nfc_digital_dev *ddev, void *arg,
612 struct sk_buff *resp)
613{
614 u8 sens_req;
615 int rc;
616
617 if (IS_ERR(resp)) {
618 rc = PTR_ERR(resp);
619 resp = NULL;
620 goto exit;
621 }
622
623 sens_req = resp->data[0];
624
625 if (!resp->len || (sens_req != DIGITAL_CMD_SENS_REQ &&
626 sens_req != DIGITAL_CMD_ALL_REQ)) {
627 rc = -EINVAL;
628 goto exit;
629 }
630
631 rc = digital_tg_send_sens_res(ddev);
632
633exit:
634 if (rc)
635 digital_poll_next_tech(ddev);
636
637 dev_kfree_skb(resp);
638}
639
640int digital_tg_send_sensf_res(struct nfc_digital_dev *ddev,
641 struct digital_sensf_req *sensf_req)
642{
643 struct sk_buff *skb;
644 u8 size;
645 int rc;
646 struct digital_sensf_res *sensf_res;
647
648 size = sizeof(struct digital_sensf_res);
649
650 if (sensf_req->rc != DIGITAL_SENSF_REQ_RC_NONE)
651 size -= sizeof(sensf_res->rd);
652
653 skb = digital_skb_alloc(ddev, size);
654 if (!skb)
655 return -ENOMEM;
656
657 skb_put(skb, size);
658
659 sensf_res = (struct digital_sensf_res *)skb->data;
660
661 memset(sensf_res, 0, size);
662
663 sensf_res->cmd = DIGITAL_CMD_SENSF_RES;
664 sensf_res->nfcid2[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1;
665 sensf_res->nfcid2[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2;
666 get_random_bytes(&sensf_res->nfcid2[2], 6);
667
668 switch (sensf_req->rc) {
669 case DIGITAL_SENSF_REQ_RC_SC:
670 sensf_res->rd[0] = sensf_req->sc1;
671 sensf_res->rd[1] = sensf_req->sc2;
672 break;
673 case DIGITAL_SENSF_REQ_RC_AP:
674 sensf_res->rd[0] = DIGITAL_SENSF_RES_RD_AP_B1;
675 sensf_res->rd[1] = DIGITAL_SENSF_RES_RD_AP_B2;
676 break;
677 }
678
679 *skb_push(skb, sizeof(u8)) = size + 1;
680
681 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev))
682 digital_skb_add_crc_f(skb);
683
684 rc = digital_tg_send_cmd(ddev, skb, 300,
685 digital_tg_recv_atr_req, NULL);
686 if (rc)
687 kfree_skb(skb);
688
689 return rc;
690}
691
692void digital_tg_recv_sensf_req(struct nfc_digital_dev *ddev, void *arg,
693 struct sk_buff *resp)
694{
695 struct digital_sensf_req *sensf_req;
696 int rc;
697
698 if (IS_ERR(resp)) {
699 rc = PTR_ERR(resp);
700 resp = NULL;
701 goto exit;
702 }
703
704 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
705 rc = digital_skb_check_crc_f(resp);
706 if (rc) {
707 PROTOCOL_ERR("6.4.1.8");
708 goto exit;
709 }
710 }
711
712 if (resp->len != sizeof(struct digital_sensf_req) + 1) {
713 rc = -EINVAL;
714 goto exit;
715 }
716
717 skb_pull(resp, 1);
718 sensf_req = (struct digital_sensf_req *)resp->data;
719
720 if (sensf_req->cmd != DIGITAL_CMD_SENSF_REQ) {
721 rc = -EINVAL;
722 goto exit;
723 }
724
725 rc = digital_tg_send_sensf_res(ddev, sensf_req);
726
727exit:
728 if (rc)
729 digital_poll_next_tech(ddev);
730
731 dev_kfree_skb(resp);
732}
733
734int digital_tg_listen_nfca(struct nfc_digital_dev *ddev, u8 rf_tech)
735{
736 int rc;
737
738 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
739 if (rc)
740 return rc;
741
742 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
743 NFC_DIGITAL_FRAMING_NFCA_NFC_DEP);
744 if (rc)
745 return rc;
746
747 return digital_tg_listen(ddev, 300, digital_tg_recv_sens_req, NULL);
748}
749
750int digital_tg_listen_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech)
751{
752 int rc;
753 u8 *nfcid2;
754
755 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
756 if (rc)
757 return rc;
758
759 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
760 NFC_DIGITAL_FRAMING_NFCF_NFC_DEP);
761 if (rc)
762 return rc;
763
764 nfcid2 = kzalloc(NFC_NFCID2_MAXSIZE, GFP_KERNEL);
765 if (!nfcid2)
766 return -ENOMEM;
767
768 nfcid2[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1;
769 nfcid2[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2;
770 get_random_bytes(nfcid2 + 2, NFC_NFCID2_MAXSIZE - 2);
771
772 return digital_tg_listen(ddev, 300, digital_tg_recv_sensf_req, nfcid2);
773}
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-28 17:25:09 -0500