projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
NFC: digital: Add NFC-DEP Receive Chaining Support
[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
3bd2a5bc
MG		 45#define DIGITAL_NFC_DEP_REQ_RES_HEADROOM 2 /* SoD: [SB (NFC-A)] + LEN */
46#define DIGITAL_NFC_DEP_REQ_RES_TAILROOM 2 /* EoD: 2-byte CRC */
47
7d0911c0
TE		 48#define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0)
49
50#define DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT 0x10
3bd2a5bc
MG		 51#define DIGITAL_NFC_DEP_PFB_MI_BIT 0x10
52#define DIGITAL_NFC_DEP_PFB_NACK_BIT 0x10
05afedcb 53#define DIGITAL_NFC_DEP_PFB_DID_BIT 0x04
7d0911c0
TE		 54
55#define DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb) \
56 ((pfb) & DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT)
3bd2a5bc
MG		 57#define DIGITAL_NFC_DEP_MI_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_MI_BIT)
58#define DIGITAL_NFC_DEP_NACK_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_NACK_BIT)
7d0911c0 59#define DIGITAL_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08)
05afedcb 60#define DIGITAL_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_DID_BIT)
7d0911c0
TE		 61#define DIGITAL_NFC_DEP_PFB_PNI(pfb) ((pfb) & 0x03)
62
63#define DIGITAL_NFC_DEP_PFB_I_PDU 0x00
64#define DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU 0x40
65#define DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU 0x80
66
67struct digital_atr_req {
68 u8 dir;
69 u8 cmd;
70 u8 nfcid3[10];
71 u8 did;
72 u8 bs;
73 u8 br;
74 u8 pp;
75 u8 gb[0];
76} __packed;
77
78struct digital_atr_res {
79 u8 dir;
80 u8 cmd;
81 u8 nfcid3[10];
82 u8 did;
83 u8 bs;
84 u8 br;
85 u8 to;
86 u8 pp;
87 u8 gb[0];
88} __packed;
89
90struct digital_psl_req {
91 u8 dir;
92 u8 cmd;
93 u8 did;
94 u8 brs;
95 u8 fsl;
96} __packed;
97
98struct digital_psl_res {
99 u8 dir;
100 u8 cmd;
101 u8 did;
102} __packed;
103
104struct digital_dep_req_res {
105 u8 dir;
106 u8 cmd;
107 u8 pfb;
108} __packed;
109
110static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
111 struct sk_buff *resp);
c12715ab
MG		 112static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
113 struct sk_buff *resp);
7d0911c0 114
b08147cb
MG		 115static const u8 digital_payload_bits_map[4] = {
116 [0] = 64,
117 [1] = 128,
118 [2] = 192,
119 [3] = 254
120};
121
122static u8 digital_payload_bits_to_size(u8 payload_bits)
123{
124 if (payload_bits >= ARRAY_SIZE(digital_payload_bits_map))
125 return 0;
126
127 return digital_payload_bits_map[payload_bits];
128}
129
130static u8 digital_payload_size_to_bits(u8 payload_size)
131{
132 int i;
133
134 for (i = 0; i < ARRAY_SIZE(digital_payload_bits_map); i++)
135 if (digital_payload_bits_map[i] == payload_size)
136 return i;
137
138 return 0xff;
139}
140
7d0911c0
TE		 141static void digital_skb_push_dep_sod(struct nfc_digital_dev *ddev,
142 struct sk_buff *skb)
143{
144 skb_push(skb, sizeof(u8));
145
146 skb->data[0] = skb->len;
147
148 if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
149 *skb_push(skb, sizeof(u8)) = DIGITAL_NFC_DEP_NFCA_SOD_SB;
150}
151
152static int digital_skb_pull_dep_sod(struct nfc_digital_dev *ddev,
153 struct sk_buff *skb)
154{
155 u8 size;
156
157 if (skb->len < 2)
158 return -EIO;
159
160 if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
161 skb_pull(skb, sizeof(u8));
162
163 size = skb->data[0];
164 if (size != skb->len)
165 return -EIO;
166
167 skb_pull(skb, sizeof(u8));
168
169 return 0;
170}
171
3bd2a5bc
MG		 172static struct sk_buff *
173digital_send_dep_data_prep(struct nfc_digital_dev *ddev, struct sk_buff *skb,
174 struct digital_dep_req_res *dep_req_res,
175 struct digital_data_exch *data_exch)
176{
177 struct sk_buff *new_skb;
178
179 if (skb->len > ddev->remote_payload_max) {
180 dep_req_res->pfb |= DIGITAL_NFC_DEP_PFB_MI_BIT;
181
182 new_skb = digital_skb_alloc(ddev, ddev->remote_payload_max);
183 if (!new_skb) {
184 kfree_skb(ddev->chaining_skb);
185 ddev->chaining_skb = NULL;
186
187 return ERR_PTR(-ENOMEM);
188 }
189
190 skb_reserve(new_skb, ddev->tx_headroom + NFC_HEADER_SIZE +
191 DIGITAL_NFC_DEP_REQ_RES_HEADROOM);
192 memcpy(skb_put(new_skb, ddev->remote_payload_max), skb->data,
193 ddev->remote_payload_max);
194 skb_pull(skb, ddev->remote_payload_max);
195
196 ddev->chaining_skb = skb;
197 ddev->data_exch = data_exch;
198 } else {
199 ddev->chaining_skb = NULL;
200 new_skb = skb;
201 }
202
203 return new_skb;
204}
205
c12715ab
MG		 206static struct sk_buff *
207digital_recv_dep_data_gather(struct nfc_digital_dev *ddev, u8 pfb,
208 struct sk_buff *resp,
209 int (*send_ack)(struct nfc_digital_dev *ddev,
210 struct digital_data_exch
211 *data_exch),
212 struct digital_data_exch *data_exch)
213{
214 struct sk_buff *new_skb;
215 int rc;
216
217 if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb) && (!ddev->chaining_skb)) {
218 ddev->chaining_skb =
219 nfc_alloc_recv_skb(8 * ddev->local_payload_max,
220 GFP_KERNEL);
221 if (!ddev->chaining_skb) {
222 rc = -ENOMEM;
223 goto error;
224 }
225 }
226
227 if (ddev->chaining_skb) {
228 if (resp->len > skb_tailroom(ddev->chaining_skb)) {
229 new_skb = skb_copy_expand(ddev->chaining_skb,
230 skb_headroom(
231 ddev->chaining_skb),
232 8 * ddev->local_payload_max,
233 GFP_KERNEL);
234 if (!new_skb) {
235 rc = -ENOMEM;
236 goto error;
237 }
238
239 kfree_skb(ddev->chaining_skb);
240 ddev->chaining_skb = new_skb;
241 }
242
243 memcpy(skb_put(ddev->chaining_skb, resp->len), resp->data,
244 resp->len);
245
246 kfree_skb(resp);
247 resp = NULL;
248
249 if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb)) {
250 rc = send_ack(ddev, data_exch);
251 if (rc)
252 goto error;
253
254 return NULL;
255 }
256
257 resp = ddev->chaining_skb;
258 ddev->chaining_skb = NULL;
259 }
260
261 return resp;
262
263error:
264 kfree_skb(resp);
265
266 kfree_skb(ddev->chaining_skb);
267 ddev->chaining_skb = NULL;
268
269 return ERR_PTR(rc);
270}
271
dddb3da0
MG		 272static void digital_in_recv_psl_res(struct nfc_digital_dev *ddev, void *arg,
273 struct sk_buff *resp)
274{
275 struct nfc_target *target = arg;
276 struct digital_psl_res *psl_res;
277 int rc;
278
279 if (IS_ERR(resp)) {
280 rc = PTR_ERR(resp);
281 resp = NULL;
282 goto exit;
283 }
284
285 rc = ddev->skb_check_crc(resp);
286 if (rc) {
287 PROTOCOL_ERR("14.4.1.6");
288 goto exit;
289 }
290
291 rc = digital_skb_pull_dep_sod(ddev, resp);
292 if (rc) {
293 PROTOCOL_ERR("14.4.1.2");
294 goto exit;
295 }
296
297 psl_res = (struct digital_psl_res *)resp->data;
298
299 if ((resp->len != sizeof(*psl_res)) ||
300 (psl_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN) ||
301 (psl_res->cmd != DIGITAL_CMD_PSL_RES)) {
302 rc = -EIO;
303 goto exit;
304 }
305
306 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
307 NFC_DIGITAL_RF_TECH_424F);
308 if (rc)
309 goto exit;
310
311 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
312 NFC_DIGITAL_FRAMING_NFCF_NFC_DEP);
313 if (rc)
314 goto exit;
315
316 if (!DIGITAL_DRV_CAPS_IN_CRC(ddev) &&
317 (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)) {
318 ddev->skb_add_crc = digital_skb_add_crc_f;
319 ddev->skb_check_crc = digital_skb_check_crc_f;
320 }
321
322 ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_424F;
323
324 nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
325 NFC_RF_INITIATOR);
326
327 ddev->curr_nfc_dep_pni = 0;
328
329exit:
330 dev_kfree_skb(resp);
331
332 if (rc)
333 ddev->curr_protocol = 0;
334}
335
336static int digital_in_send_psl_req(struct nfc_digital_dev *ddev,
337 struct nfc_target *target)
338{
339 struct sk_buff *skb;
340 struct digital_psl_req *psl_req;
b15829ba 341 int rc;
b08147cb 342 u8 payload_size, payload_bits;
dddb3da0
MG		 343
344 skb = digital_skb_alloc(ddev, sizeof(*psl_req));
345 if (!skb)
346 return -ENOMEM;
347
348 skb_put(skb, sizeof(*psl_req));
349
350 psl_req = (struct digital_psl_req *)skb->data;
351
352 psl_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
353 psl_req->cmd = DIGITAL_CMD_PSL_REQ;
354 psl_req->did = 0;
355 psl_req->brs = (0x2 << 3) | 0x2; /* 424F both directions */
b08147cb
MG		 356
357 payload_size = min(ddev->local_payload_max, ddev->remote_payload_max);
358 payload_bits = digital_payload_size_to_bits(payload_size);
359 psl_req->fsl = DIGITAL_PAYLOAD_BITS_TO_FSL(payload_bits);
360
361 ddev->local_payload_max = payload_size;
362 ddev->remote_payload_max = payload_size;
dddb3da0
MG		 363
364 digital_skb_push_dep_sod(ddev, skb);
365
366 ddev->skb_add_crc(skb);
367
b15829ba
MG		 368 rc = digital_in_send_cmd(ddev, skb, 500, digital_in_recv_psl_res,
369 target);
370 if (rc)
371 kfree_skb(skb);
372
373 return rc;
dddb3da0
MG		 374}
375
7d0911c0
TE		 376static void digital_in_recv_atr_res(struct nfc_digital_dev *ddev, void *arg,
377 struct sk_buff *resp)
378{
379 struct nfc_target *target = arg;
380 struct digital_atr_res *atr_res;
b08147cb 381 u8 gb_len, payload_bits;
7d0911c0
TE		 382 int rc;
383
384 if (IS_ERR(resp)) {
385 rc = PTR_ERR(resp);
386 resp = NULL;
387 goto exit;
388 }
389
390 rc = ddev->skb_check_crc(resp);
391 if (rc) {
392 PROTOCOL_ERR("14.4.1.6");
393 goto exit;
394 }
395
396 rc = digital_skb_pull_dep_sod(ddev, resp);
397 if (rc) {
398 PROTOCOL_ERR("14.4.1.2");
399 goto exit;
400 }
401
402 if (resp->len < sizeof(struct digital_atr_res)) {
403 rc = -EIO;
404 goto exit;
405 }
406
407 gb_len = resp->len - sizeof(struct digital_atr_res);
408
409 atr_res = (struct digital_atr_res *)resp->data;
410
b08147cb
MG		 411 payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_res->pp);
412 ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
413
414 if (!ddev->remote_payload_max) {
415 rc = -EINVAL;
416 goto exit;
417 }
418
7d0911c0
TE		 419 rc = nfc_set_remote_general_bytes(ddev->nfc_dev, atr_res->gb, gb_len);
420 if (rc)
421 goto exit;
422
dddb3da0
MG		 423 if ((ddev->protocols & NFC_PROTO_FELICA_MASK) &&
424 (ddev->curr_rf_tech != NFC_DIGITAL_RF_TECH_424F)) {
425 rc = digital_in_send_psl_req(ddev, target);
426 if (!rc)
427 goto exit;
428 }
429
7d0911c0
TE		 430 rc = nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
431 NFC_RF_INITIATOR);
432
433 ddev->curr_nfc_dep_pni = 0;
434
435exit:
436 dev_kfree_skb(resp);
437
438 if (rc)
439 ddev->curr_protocol = 0;
440}
441
442int digital_in_send_atr_req(struct nfc_digital_dev *ddev,
443 struct nfc_target *target, __u8 comm_mode, __u8 *gb,
444 size_t gb_len)
445{
446 struct sk_buff *skb;
447 struct digital_atr_req *atr_req;
448 uint size;
b15829ba 449 int rc;
b08147cb 450 u8 payload_bits;
7d0911c0
TE		 451
452 size = DIGITAL_ATR_REQ_MIN_SIZE + gb_len;
453
454 if (size > DIGITAL_ATR_REQ_MAX_SIZE) {
455 PROTOCOL_ERR("14.6.1.1");
456 return -EINVAL;
457 }
458
459 skb = digital_skb_alloc(ddev, size);
460 if (!skb)
461 return -ENOMEM;
462
463 skb_put(skb, sizeof(struct digital_atr_req));
464
465 atr_req = (struct digital_atr_req *)skb->data;
466 memset(atr_req, 0, sizeof(struct digital_atr_req));
467
468 atr_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
469 atr_req->cmd = DIGITAL_CMD_ATR_REQ;
470 if (target->nfcid2_len)
4f319e32 471 memcpy(atr_req->nfcid3, target->nfcid2, NFC_NFCID2_MAXSIZE);
7d0911c0 472 else
4f319e32 473 get_random_bytes(atr_req->nfcid3, NFC_NFCID3_MAXSIZE);
7d0911c0
TE		 474
475 atr_req->did = 0;
476 atr_req->bs = 0;
477 atr_req->br = 0;
478
b08147cb
MG		 479 ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX;
480 payload_bits = digital_payload_size_to_bits(ddev->local_payload_max);
481 atr_req->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits);
7d0911c0
TE		 482
483 if (gb_len) {
484 atr_req->pp |= DIGITAL_GB_BIT;
485 memcpy(skb_put(skb, gb_len), gb, gb_len);
486 }
487
488 digital_skb_push_dep_sod(ddev, skb);
489
490 ddev->skb_add_crc(skb);
491
b15829ba
MG		 492 rc = digital_in_send_cmd(ddev, skb, 500, digital_in_recv_atr_res,
493 target);
494 if (rc)
495 kfree_skb(skb);
496
497 return rc;
7d0911c0
TE		 498}
499
c12715ab
MG		 500static int digital_in_send_ack(struct nfc_digital_dev *ddev,
501 struct digital_data_exch *data_exch)
502{
503 struct digital_dep_req_res *dep_req;
504 struct sk_buff *skb;
505 int rc;
506
507 skb = digital_skb_alloc(ddev, 1);
508 if (!skb)
509 return -ENOMEM;
510
511 skb_push(skb, sizeof(struct digital_dep_req_res));
512
513 dep_req = (struct digital_dep_req_res *)skb->data;
514
515 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
516 dep_req->cmd = DIGITAL_CMD_DEP_REQ;
517 dep_req->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
518 ddev->curr_nfc_dep_pni;
519
520 digital_skb_push_dep_sod(ddev, skb);
521
522 ddev->skb_add_crc(skb);
523
524 rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
525 data_exch);
526 if (rc)
527 kfree_skb(skb);
528
529 return rc;
530}
531
7d0911c0
TE		 532static int digital_in_send_rtox(struct nfc_digital_dev *ddev,
533 struct digital_data_exch *data_exch, u8 rtox)
534{
535 struct digital_dep_req_res *dep_req;
536 struct sk_buff *skb;
537 int rc;
538
539 skb = digital_skb_alloc(ddev, 1);
540 if (!skb)
541 return -ENOMEM;
542
543 *skb_put(skb, 1) = rtox;
544
545 skb_push(skb, sizeof(struct digital_dep_req_res));
546
547 dep_req = (struct digital_dep_req_res *)skb->data;
548
549 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
550 dep_req->cmd = DIGITAL_CMD_DEP_REQ;
551 dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU |
552 DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT;
553
554 digital_skb_push_dep_sod(ddev, skb);
555
556 ddev->skb_add_crc(skb);
557
558 rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
559 data_exch);
b15829ba
MG		 560 if (rc)
561 kfree_skb(skb);
7d0911c0
TE		 562
563 return rc;
564}
565
566static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
567 struct sk_buff *resp)
568{
569 struct digital_data_exch *data_exch = arg;
570 struct digital_dep_req_res *dep_res;
571 u8 pfb;
572 uint size;
573 int rc;
574
575 if (IS_ERR(resp)) {
576 rc = PTR_ERR(resp);
577 resp = NULL;
578 goto exit;
579 }
580
581 rc = ddev->skb_check_crc(resp);
582 if (rc) {
583 PROTOCOL_ERR("14.4.1.6");
584 goto error;
585 }
586
587 rc = digital_skb_pull_dep_sod(ddev, resp);
588 if (rc) {
589 PROTOCOL_ERR("14.4.1.2");
590 goto exit;
591 }
592
b08147cb
MG		 593 if (resp->len > ddev->local_payload_max) {
594 rc = -EMSGSIZE;
595 goto exit;
596 }
597
6ce30668 598 size = sizeof(struct digital_dep_req_res);
7d0911c0
TE		 599 dep_res = (struct digital_dep_req_res *)resp->data;
600
6ce30668 601 if (resp->len < size || dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN ||
7d0911c0
TE		 602 dep_res->cmd != DIGITAL_CMD_DEP_RES) {
603 rc = -EIO;
604 goto error;
605 }
606
607 pfb = dep_res->pfb;
608
3bc3f88a
MG		 609 if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
610 PROTOCOL_ERR("14.8.2.1");
611 rc = -EIO;
612 goto error;
613 }
6ce30668 614
3e6b0de8
MG		 615 if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
616 rc = -EIO;
617 goto exit;
618 }
619
6ce30668
MG		 620 if (size > resp->len) {
621 rc = -EIO;
622 goto error;
623 }
624
625 skb_pull(resp, size);
626
7d0911c0
TE		 627 switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
628 case DIGITAL_NFC_DEP_PFB_I_PDU:
629 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
630 PROTOCOL_ERR("14.12.3.3");
631 rc = -EIO;
632 goto error;
633 }
634
635 ddev->curr_nfc_dep_pni =
636 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
c12715ab
MG		 637
638 resp = digital_recv_dep_data_gather(ddev, pfb, resp,
639 digital_in_send_ack,
640 data_exch);
641 if (IS_ERR(resp)) {
642 rc = PTR_ERR(resp);
643 resp = NULL;
644 goto error;
645 }
646
647 /* If resp is NULL then we're still chaining so return and
648 * wait for the next part of the PDU. Else, the PDU is
649 * complete so pass it up.
650 */
651 if (!resp)
652 return;
653
7d0911c0
TE		 654 rc = 0;
655 break;
656
657 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
485fdc9b
MG		 658 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
659 PROTOCOL_ERR("14.12.3.3");
660 rc = -EIO;
661 goto exit;
662 }
663
664 ddev->curr_nfc_dep_pni =
665 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
666
3bd2a5bc
MG		 667 if (ddev->chaining_skb && !DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) {
668 rc = digital_in_send_dep_req(ddev, NULL,
669 ddev->chaining_skb,
670 ddev->data_exch);
671 if (rc)
672 goto error;
673
674 return;
675 }
676
677 pr_err("Received a ACK/NACK PDU\n");
485fdc9b
MG		 678 rc = -EINVAL;
679 goto exit;
7d0911c0
TE		 680
681 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
682 if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) {
683 rc = -EINVAL;
684 goto error;
685 }
686
6ce30668 687 rc = digital_in_send_rtox(ddev, data_exch, resp->data[0]);
7d0911c0
TE		 688 if (rc)
689 goto error;
690
691 kfree_skb(resp);
692 return;
693 }
694
7d0911c0
TE		 695exit:
696 data_exch->cb(data_exch->cb_context, resp, rc);
697
698error:
699 kfree(data_exch);
700
3bd2a5bc
MG		 701 kfree_skb(ddev->chaining_skb);
702 ddev->chaining_skb = NULL;
703
7d0911c0
TE		 704 if (rc)
705 kfree_skb(resp);
706}
707
708int digital_in_send_dep_req(struct nfc_digital_dev *ddev,
709 struct nfc_target *target, struct sk_buff *skb,
710 struct digital_data_exch *data_exch)
711{
712 struct digital_dep_req_res *dep_req;
3bd2a5bc
MG		 713 struct sk_buff *chaining_skb, *tmp_skb;
714 int rc;
7d0911c0
TE		 715
716 skb_push(skb, sizeof(struct digital_dep_req_res));
717
718 dep_req = (struct digital_dep_req_res *)skb->data;
3bd2a5bc 719
7d0911c0
TE		 720 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
721 dep_req->cmd = DIGITAL_CMD_DEP_REQ;
722 dep_req->pfb = ddev->curr_nfc_dep_pni;
723
3bd2a5bc 724 chaining_skb = ddev->chaining_skb;
7d0911c0 725
3bd2a5bc
MG		 726 tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_req, data_exch);
727 if (IS_ERR(tmp_skb))
728 return PTR_ERR(tmp_skb);
7d0911c0 729
3bd2a5bc
MG		 730 digital_skb_push_dep_sod(ddev, tmp_skb);
731
732 ddev->skb_add_crc(tmp_skb);
733
734 rc = digital_in_send_cmd(ddev, tmp_skb, 1500, digital_in_recv_dep_res,
735 data_exch);
736 if (rc) {
737 if (tmp_skb != skb)
738 kfree_skb(tmp_skb);
739
740 kfree_skb(chaining_skb);
741 ddev->chaining_skb = NULL;
742 }
743
744 return rc;
7d0911c0 745}
1c7a4c24 746
b711ad52
TE		 747static void digital_tg_set_rf_tech(struct nfc_digital_dev *ddev, u8 rf_tech)
748{
749 ddev->curr_rf_tech = rf_tech;
750
751 ddev->skb_add_crc = digital_skb_add_crc_none;
752 ddev->skb_check_crc = digital_skb_check_crc_none;
753
754 if (DIGITAL_DRV_CAPS_TG_CRC(ddev))
755 return;
756
757 switch (ddev->curr_rf_tech) {
758 case NFC_DIGITAL_RF_TECH_106A:
759 ddev->skb_add_crc = digital_skb_add_crc_a;
760 ddev->skb_check_crc = digital_skb_check_crc_a;
761 break;
762
763 case NFC_DIGITAL_RF_TECH_212F:
764 case NFC_DIGITAL_RF_TECH_424F:
765 ddev->skb_add_crc = digital_skb_add_crc_f;
766 ddev->skb_check_crc = digital_skb_check_crc_f;
767 break;
768
769 default:
770 break;
771 }
772}
773
c12715ab
MG		 774static int digital_tg_send_ack(struct nfc_digital_dev *ddev,
775 struct digital_data_exch *data_exch)
776{
777 struct digital_dep_req_res *dep_res;
778 struct sk_buff *skb;
779 int rc;
780
781 skb = digital_skb_alloc(ddev, 1);
782 if (!skb)
783 return -ENOMEM;
784
785 skb_push(skb, sizeof(struct digital_dep_req_res));
786
787 dep_res = (struct digital_dep_req_res *)skb->data;
788
789 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
790 dep_res->cmd = DIGITAL_CMD_DEP_RES;
791 dep_res->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
792 ddev->curr_nfc_dep_pni;
793
794 if (ddev->did) {
795 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
796
797 memcpy(skb_put(skb, sizeof(ddev->did)), &ddev->did,
798 sizeof(ddev->did));
799 }
800
801 ddev->curr_nfc_dep_pni =
802 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
803
804 digital_skb_push_dep_sod(ddev, skb);
805
806 ddev->skb_add_crc(skb);
807
808 rc = digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
809 data_exch);
810 if (rc)
811 kfree_skb(skb);
812
813 return rc;
814}
815
1c7a4c24
TE		 816static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
817 struct sk_buff *resp)
818{
819 int rc;
820 struct digital_dep_req_res *dep_req;
6ce30668 821 u8 pfb;
1c7a4c24
TE		 822 size_t size;
823
824 if (IS_ERR(resp)) {
825 rc = PTR_ERR(resp);
826 resp = NULL;
827 goto exit;
828 }
829
830 rc = ddev->skb_check_crc(resp);
831 if (rc) {
832 PROTOCOL_ERR("14.4.1.6");
833 goto exit;
834 }
835
836 rc = digital_skb_pull_dep_sod(ddev, resp);
837 if (rc) {
838 PROTOCOL_ERR("14.4.1.2");
839 goto exit;
840 }
841
b08147cb
MG		 842 if (resp->len > ddev->local_payload_max) {
843 rc = -EMSGSIZE;
844 goto exit;
845 }
846
1c7a4c24
TE		 847 size = sizeof(struct digital_dep_req_res);
848 dep_req = (struct digital_dep_req_res *)resp->data;
849
850 if (resp->len < size || dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
851 dep_req->cmd != DIGITAL_CMD_DEP_REQ) {
852 rc = -EIO;
853 goto exit;
854 }
855
6ce30668
MG		 856 pfb = dep_req->pfb;
857
05afedcb
MG		 858 if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
859 if (ddev->did && (ddev->did == resp->data[3])) {
860 size++;
861 } else {
862 rc = -EIO;
863 goto exit;
864 }
865 } else if (ddev->did) {
866 rc = -EIO;
867 goto exit;
868 }
1c7a4c24 869
3e6b0de8
MG		 870 if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
871 rc = -EIO;
872 goto exit;
873 }
874
6ce30668 875 if (size > resp->len) {
1c7a4c24
TE		 876 rc = -EIO;
877 goto exit;
878 }
879
6ce30668
MG		 880 skb_pull(resp, size);
881
882 switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
1c7a4c24 883 case DIGITAL_NFC_DEP_PFB_I_PDU:
26042530 884 pr_debug("DIGITAL_NFC_DEP_PFB_I_PDU\n");
485fdc9b
MG		 885
886 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
887 PROTOCOL_ERR("14.12.3.4");
888 rc = -EIO;
889 goto exit;
890 }
891
c12715ab
MG		 892 resp = digital_recv_dep_data_gather(ddev, pfb, resp,
893 digital_tg_send_ack, NULL);
894 if (IS_ERR(resp)) {
895 rc = PTR_ERR(resp);
896 resp = NULL;
897 goto exit;
898 }
899
900 /* If resp is NULL then we're still chaining so return and
901 * wait for the next part of the PDU. Else, the PDU is
902 * complete so pass it up.
903 */
904 if (!resp)
905 return;
906
485fdc9b 907 rc = 0;
1c7a4c24
TE		 908 break;
909 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
485fdc9b
MG		 910 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
911 PROTOCOL_ERR("14.12.3.4");
912 rc = -EIO;
913 goto exit;
914 }
915
3bd2a5bc
MG		 916 if (ddev->chaining_skb && !DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) {
917 rc = digital_tg_send_dep_res(ddev, ddev->chaining_skb);
918 if (rc)
919 goto exit;
920
921 return;
922 }
923
26042530 924 pr_err("Received a ACK/NACK PDU\n");
1c7a4c24
TE		 925 rc = -EINVAL;
926 goto exit;
1c7a4c24 927 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
26042530 928 pr_err("Received a SUPERVISOR PDU\n");
1c7a4c24
TE		 929 rc = -EINVAL;
930 goto exit;
1c7a4c24
TE		 931 }
932
1c7a4c24
TE		 933 rc = nfc_tm_data_received(ddev->nfc_dev, resp);
934
935exit:
3bd2a5bc
MG		 936 kfree_skb(ddev->chaining_skb);
937 ddev->chaining_skb = NULL;
938
1c7a4c24
TE		 939 if (rc)
940 kfree_skb(resp);
941}
942
943int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb)
944{
945 struct digital_dep_req_res *dep_res;
3bd2a5bc
MG		 946 struct sk_buff *chaining_skb, *tmp_skb;
947 int rc;
1c7a4c24
TE		 948
949 skb_push(skb, sizeof(struct digital_dep_req_res));
b08147cb 950
1c7a4c24
TE		 951 dep_res = (struct digital_dep_req_res *)skb->data;
952
953 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
954 dep_res->cmd = DIGITAL_CMD_DEP_RES;
955 dep_res->pfb = ddev->curr_nfc_dep_pni;
956
05afedcb
MG		 957 if (ddev->did) {
958 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
959
960 memcpy(skb_put(skb, sizeof(ddev->did)), &ddev->did,
961 sizeof(ddev->did));
962 }
963
485fdc9b
MG		 964 ddev->curr_nfc_dep_pni =
965 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
966
3bd2a5bc 967 chaining_skb = ddev->chaining_skb;
1c7a4c24 968
3bd2a5bc
MG		 969 tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_res, NULL);
970 if (IS_ERR(tmp_skb))
971 return PTR_ERR(tmp_skb);
972
973 digital_skb_push_dep_sod(ddev, tmp_skb);
974
975 ddev->skb_add_crc(tmp_skb);
1c7a4c24 976
3bd2a5bc
MG		 977 rc = digital_tg_send_cmd(ddev, tmp_skb, 1500, digital_tg_recv_dep_req,
978 NULL);
979 if (rc) {
980 if (tmp_skb != skb)
981 kfree_skb(tmp_skb);
982
983 kfree_skb(chaining_skb);
984 ddev->chaining_skb = NULL;
985 }
986
987 return rc;
1c7a4c24
TE		 988}
989
990static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev,
991 void *arg, struct sk_buff *resp)
992{
67af1d7a 993 u8 rf_tech = (unsigned long)arg;
1c7a4c24
TE		 994
995 if (IS_ERR(resp))
996 return;
997
b711ad52
TE		 998 digital_tg_set_rf_tech(ddev, rf_tech);
999
1c7a4c24
TE		 1000 digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
1001
1002 digital_tg_listen(ddev, 1500, digital_tg_recv_dep_req, NULL);
1003
1004 dev_kfree_skb(resp);
1005}
1006
1007static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did,
1008 u8 rf_tech)
1009{
1010 struct digital_psl_res *psl_res;
1011 struct sk_buff *skb;
1012 int rc;
1013
1014 skb = digital_skb_alloc(ddev, sizeof(struct digital_psl_res));
1015 if (!skb)
1016 return -ENOMEM;
1017
1018 skb_put(skb, sizeof(struct digital_psl_res));
1019
1020 psl_res = (struct digital_psl_res *)skb->data;
1021
1022 psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1023 psl_res->cmd = DIGITAL_CMD_PSL_RES;
1024 psl_res->did = did;
1025
1026 digital_skb_push_dep_sod(ddev, skb);
1027
1028 ddev->skb_add_crc(skb);
1029
485fdc9b
MG		 1030 ddev->curr_nfc_dep_pni = 0;
1031
1c7a4c24 1032 rc = digital_tg_send_cmd(ddev, skb, 0, digital_tg_send_psl_res_complete,
67af1d7a 1033 (void *)(unsigned long)rf_tech);
1c7a4c24
TE		 1034 if (rc)
1035 kfree_skb(skb);
1036
1037 return rc;
1038}
1039
1040static void digital_tg_recv_psl_req(struct nfc_digital_dev *ddev, void *arg,
1041 struct sk_buff *resp)
1042{
1043 int rc;
1044 struct digital_psl_req *psl_req;
1045 u8 rf_tech;
b08147cb 1046 u8 dsi, payload_size, payload_bits;
1c7a4c24
TE		 1047
1048 if (IS_ERR(resp)) {
1049 rc = PTR_ERR(resp);
1050 resp = NULL;
1051 goto exit;
1052 }
1053
1054 rc = ddev->skb_check_crc(resp);
1055 if (rc) {
1056 PROTOCOL_ERR("14.4.1.6");
1057 goto exit;
1058 }
1059
1060 rc = digital_skb_pull_dep_sod(ddev, resp);
1061 if (rc) {
1062 PROTOCOL_ERR("14.4.1.2");
1063 goto exit;
1064 }
1065
1066 psl_req = (struct digital_psl_req *)resp->data;
1067
1068 if (resp->len != sizeof(struct digital_psl_req) ||
1069 psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1070 psl_req->cmd != DIGITAL_CMD_PSL_REQ) {
1071 rc = -EIO;
1072 goto exit;
1073 }
1074
1075 dsi = (psl_req->brs >> 3) & 0x07;
1076 switch (dsi) {
1077 case 0:
1078 rf_tech = NFC_DIGITAL_RF_TECH_106A;
1079 break;
1080 case 1:
1081 rf_tech = NFC_DIGITAL_RF_TECH_212F;
1082 break;
1083 case 2:
1084 rf_tech = NFC_DIGITAL_RF_TECH_424F;
1085 break;
1086 default:
77d84ff8 1087 pr_err("Unsupported dsi value %d\n", dsi);
1c7a4c24
TE		 1088 goto exit;
1089 }
1090
b08147cb
MG		 1091 payload_bits = DIGITAL_PAYLOAD_FSL_TO_BITS(psl_req->fsl);
1092 payload_size = digital_payload_bits_to_size(payload_bits);
1093
1094 if (!payload_size || (payload_size > min(ddev->local_payload_max,
1095 ddev->remote_payload_max))) {
1096 rc = -EINVAL;
1097 goto exit;
1098 }
1099
1100 ddev->local_payload_max = payload_size;
1101 ddev->remote_payload_max = payload_size;
1102
1c7a4c24
TE		 1103 rc = digital_tg_send_psl_res(ddev, psl_req->did, rf_tech);
1104
1105exit:
1106 kfree_skb(resp);
1107}
1108
1109static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev,
1110 void *arg, struct sk_buff *resp)
1111{
1112 int offset;
1113
1114 if (IS_ERR(resp)) {
1115 digital_poll_next_tech(ddev);
1116 return;
1117 }
1118
1119 offset = 2;
1120 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB)
1121 offset++;
1122
1123 if (resp->data[offset] == DIGITAL_CMD_PSL_REQ)
1124 digital_tg_recv_psl_req(ddev, arg, resp);
1125 else
1126 digital_tg_recv_dep_req(ddev, arg, resp);
1127}
1128
1129static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev,
1130 struct digital_atr_req *atr_req)
1131{
1132 struct digital_atr_res *atr_res;
1133 struct sk_buff *skb;
b08147cb 1134 u8 *gb, payload_bits;
1c7a4c24
TE		 1135 size_t gb_len;
1136 int rc;
1137
1138 gb = nfc_get_local_general_bytes(ddev->nfc_dev, &gb_len);
1139 if (!gb)
1140 gb_len = 0;
1141
1142 skb = digital_skb_alloc(ddev, sizeof(struct digital_atr_res) + gb_len);
1143 if (!skb)
1144 return -ENOMEM;
1145
1146 skb_put(skb, sizeof(struct digital_atr_res));
1147 atr_res = (struct digital_atr_res *)skb->data;
1148
1149 memset(atr_res, 0, sizeof(struct digital_atr_res));
1150
1151 atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1152 atr_res->cmd = DIGITAL_CMD_ATR_RES;
1153 memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3));
1154 atr_res->to = 8;
b08147cb
MG		 1155
1156 ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX;
1157 payload_bits = digital_payload_size_to_bits(ddev->local_payload_max);
1158 atr_res->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits);
1159
1c7a4c24
TE		 1160 if (gb_len) {
1161 skb_put(skb, gb_len);
1162
1163 atr_res->pp |= DIGITAL_GB_BIT;
1164 memcpy(atr_res->gb, gb, gb_len);
1165 }
1166
1167 digital_skb_push_dep_sod(ddev, skb);
1168
1169 ddev->skb_add_crc(skb);
1170
485fdc9b
MG		 1171 ddev->curr_nfc_dep_pni = 0;
1172
1c7a4c24
TE		 1173 rc = digital_tg_send_cmd(ddev, skb, 999,
1174 digital_tg_send_atr_res_complete, NULL);
b15829ba 1175 if (rc)
1c7a4c24 1176 kfree_skb(skb);
1c7a4c24
TE		 1177
1178 return rc;
1179}
1180
1181void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg,
1182 struct sk_buff *resp)
1183{
1184 int rc;
1185 struct digital_atr_req *atr_req;
1186 size_t gb_len, min_size;
b08147cb 1187 u8 poll_tech_count, payload_bits;
1c7a4c24
TE		 1188
1189 if (IS_ERR(resp)) {
1190 rc = PTR_ERR(resp);
1191 resp = NULL;
1192 goto exit;
1193 }
1194
1195 if (!resp->len) {
1196 rc = -EIO;
1197 goto exit;
1198 }
1199
1200 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) {
1201 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2;
b711ad52 1202 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_106A);
1c7a4c24
TE		 1203 } else {
1204 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1;
b711ad52 1205 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_212F);
1c7a4c24
TE		 1206 }
1207
1208 if (resp->len < min_size) {
1209 rc = -EIO;
1210 goto exit;
1211 }
1212
48e10445 1213 ddev->curr_protocol = NFC_PROTO_NFC_DEP_MASK;
1c7a4c24
TE		 1214
1215 rc = ddev->skb_check_crc(resp);
1216 if (rc) {
1217 PROTOCOL_ERR("14.4.1.6");
1218 goto exit;
1219 }
1220
1221 rc = digital_skb_pull_dep_sod(ddev, resp);
1222 if (rc) {
1223 PROTOCOL_ERR("14.4.1.2");
1224 goto exit;
1225 }
1226
1227 atr_req = (struct digital_atr_req *)resp->data;
1228
1229 if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
05afedcb
MG		 1230 atr_req->cmd != DIGITAL_CMD_ATR_REQ ||
1231 atr_req->did > DIGITAL_DID_MAX) {
1c7a4c24
TE		 1232 rc = -EINVAL;
1233 goto exit;
1234 }
1235
b08147cb
MG		 1236 payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_req->pp);
1237 ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
1238
1239 if (!ddev->remote_payload_max) {
1240 rc = -EINVAL;
1241 goto exit;
1242 }
1243
05afedcb
MG		 1244 ddev->did = atr_req->did;
1245
1c7a4c24
TE		 1246 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1247 NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED);
1248 if (rc)
1249 goto exit;
1250
1251 rc = digital_tg_send_atr_res(ddev, atr_req);
1252 if (rc)
1253 goto exit;
1254
1255 gb_len = resp->len - sizeof(struct digital_atr_req);
0529a7ad
MG		 1256
1257 poll_tech_count = ddev->poll_tech_count;
1258 ddev->poll_tech_count = 0;
1259
1c7a4c24
TE		 1260 rc = nfc_tm_activated(ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
1261 NFC_COMM_PASSIVE, atr_req->gb, gb_len);
0529a7ad
MG		 1262 if (rc) {
1263 ddev->poll_tech_count = poll_tech_count;
1c7a4c24 1264 goto exit;
0529a7ad 1265 }
1c7a4c24
TE		 1266
1267 rc = 0;
1268exit:
1269 if (rc)
1270 digital_poll_next_tech(ddev);
1271
1272 dev_kfree_skb(resp);
1273}
Linux kernel - Deliverables
This page took 0.124567 seconds and 5 git commands to generate.