~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/nfc/digital_dep.c

Version: ~ [ linux-5.5-rc1 ] ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 16 #define pr_fmt(fmt) "digital: %s: " fmt, __func__
 17 
 18 #include "digital.h"
 19 
 20 #define DIGITAL_NFC_DEP_N_RETRY_NACK    2
 21 #define DIGITAL_NFC_DEP_N_RETRY_ATN     2
 22 
 23 #define DIGITAL_NFC_DEP_FRAME_DIR_OUT 0xD4
 24 #define DIGITAL_NFC_DEP_FRAME_DIR_IN  0xD5
 25 
 26 #define DIGITAL_NFC_DEP_NFCA_SOD_SB   0xF0
 27 
 28 #define DIGITAL_CMD_ATR_REQ 0x00
 29 #define DIGITAL_CMD_ATR_RES 0x01
 30 #define DIGITAL_CMD_PSL_REQ 0x04
 31 #define DIGITAL_CMD_PSL_RES 0x05
 32 #define DIGITAL_CMD_DEP_REQ 0x06
 33 #define DIGITAL_CMD_DEP_RES 0x07
 34 
 35 #define DIGITAL_ATR_REQ_MIN_SIZE 16
 36 #define DIGITAL_ATR_REQ_MAX_SIZE 64
 37 
 38 #define DIGITAL_ATR_RES_TO_WT(s)        ((s) & 0xF)
 39 
 40 #define DIGITAL_DID_MAX 14
 41 
 42 #define DIGITAL_PAYLOAD_SIZE_MAX        254
 43 #define DIGITAL_PAYLOAD_BITS_TO_PP(s)   (((s) & 0x3) << 4)
 44 #define DIGITAL_PAYLOAD_PP_TO_BITS(s)   (((s) >> 4) & 0x3)
 45 #define DIGITAL_PAYLOAD_BITS_TO_FSL(s)  ((s) & 0x3)
 46 #define DIGITAL_PAYLOAD_FSL_TO_BITS(s)  ((s) & 0x3)
 47 
 48 #define DIGITAL_GB_BIT  0x02
 49 
 50 #define DIGITAL_NFC_DEP_REQ_RES_HEADROOM        2 /* SoD: [SB (NFC-A)] + LEN */
 51 #define DIGITAL_NFC_DEP_REQ_RES_TAILROOM        2 /* EoD: 2-byte CRC */
 52 
 53 #define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0)
 54 
 55 #define DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT 0x10
 56 #define DIGITAL_NFC_DEP_PFB_MI_BIT      0x10
 57 #define DIGITAL_NFC_DEP_PFB_NACK_BIT    0x10
 58 #define DIGITAL_NFC_DEP_PFB_DID_BIT     0x04
 59 
 60 #define DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb) \
 61                                 ((pfb) & DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT)
 62 #define DIGITAL_NFC_DEP_MI_BIT_SET(pfb)  ((pfb) & DIGITAL_NFC_DEP_PFB_MI_BIT)
 63 #define DIGITAL_NFC_DEP_NACK_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_NACK_BIT)
 64 #define DIGITAL_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08)
 65 #define DIGITAL_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_DID_BIT)
 66 #define DIGITAL_NFC_DEP_PFB_PNI(pfb)     ((pfb) & 0x03)
 67 
 68 #define DIGITAL_NFC_DEP_RTOX_VALUE(data) ((data) & 0x3F)
 69 #define DIGITAL_NFC_DEP_RTOX_MAX         59
 70 
 71 #define DIGITAL_NFC_DEP_PFB_I_PDU          0x00
 72 #define DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU   0x40
 73 #define DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU 0x80
 74 
 75 struct digital_atr_req {
 76         u8 dir;
 77         u8 cmd;
 78         u8 nfcid3[10];
 79         u8 did;
 80         u8 bs;
 81         u8 br;
 82         u8 pp;
 83         u8 gb[0];
 84 } __packed;
 85 
 86 struct digital_atr_res {
 87         u8 dir;
 88         u8 cmd;
 89         u8 nfcid3[10];
 90         u8 did;
 91         u8 bs;
 92         u8 br;
 93         u8 to;
 94         u8 pp;
 95         u8 gb[0];
 96 } __packed;
 97 
 98 struct digital_psl_req {
 99         u8 dir;
100         u8 cmd;
101         u8 did;
102         u8 brs;
103         u8 fsl;
104 } __packed;
105 
106 struct digital_psl_res {
107         u8 dir;
108         u8 cmd;
109         u8 did;
110 } __packed;
111 
112 struct digital_dep_req_res {
113         u8 dir;
114         u8 cmd;
115         u8 pfb;
116 } __packed;
117 
118 static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
119                                     struct sk_buff *resp);
120 static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
121                                     struct sk_buff *resp);
122 
123 static const u8 digital_payload_bits_map[4] = {
124         [0] = 64,
125         [1] = 128,
126         [2] = 192,
127         [3] = 254
128 };
129 
130 /* Response Waiting Time for ATR_RES PDU in ms
131  *
132  * RWT(ATR_RES) = RWT(nfcdep,activation) + dRWT(nfcdep) + dT(nfcdep,initiator)
133  *
134  * with:
135  *  RWT(nfcdep,activation) = 4096 * 2^12 / f(c) s
136  *  dRWT(nfcdep) = 16 / f(c) s
137  *  dT(nfcdep,initiator) = 100 ms
138  *  f(c) = 13560000 Hz
139  */
140 #define DIGITAL_ATR_RES_RWT 1337
141 
142 /* Response Waiting Time for other DEP PDUs in ms
143  *
144  * max_rwt = rwt + dRWT(nfcdep) + dT(nfcdep,initiator)
145  *
146  * with:
147  *  rwt = (256 * 16 / f(c)) * 2^wt s
148  *  dRWT(nfcdep) = 16 / f(c) s
149  *  dT(nfcdep,initiator) = 100 ms
150  *  f(c) = 13560000 Hz
151  *  0 <= wt <= 14 (given by the target by the TO field of ATR_RES response)
152  */
153 #define DIGITAL_NFC_DEP_IN_MAX_WT 14
154 #define DIGITAL_NFC_DEP_TG_MAX_WT 14
155 static const u16 digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT + 1] = {
156         100,  101,  101,  102,  105,
157         110,  119,  139,  177,  255,
158         409,  719, 1337, 2575, 5049,
159 };
160 
161 static u8 digital_payload_bits_to_size(u8 payload_bits)
162 {
163         if (payload_bits >= ARRAY_SIZE(digital_payload_bits_map))
164                 return 0;
165 
166         return digital_payload_bits_map[payload_bits];
167 }
168 
169 static u8 digital_payload_size_to_bits(u8 payload_size)
170 {
171         int i;
172 
173         for (i = 0; i < ARRAY_SIZE(digital_payload_bits_map); i++)
174                 if (digital_payload_bits_map[i] == payload_size)
175                         return i;
176 
177         return 0xff;
178 }
179 
180 static void digital_skb_push_dep_sod(struct nfc_digital_dev *ddev,
181                                      struct sk_buff *skb)
182 {
183         skb_push(skb, sizeof(u8));
184 
185         skb->data[0] = skb->len;
186 
187         if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
188                 *(u8 *)skb_push(skb, sizeof(u8)) = DIGITAL_NFC_DEP_NFCA_SOD_SB;
189 }
190 
191 static int digital_skb_pull_dep_sod(struct nfc_digital_dev *ddev,
192                                     struct sk_buff *skb)
193 {
194         u8 size;
195 
196         if (skb->len < 2)
197                 return -EIO;
198 
199         if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
200                 skb_pull(skb, sizeof(u8));
201 
202         size = skb->data[0];
203         if (size != skb->len)
204                 return -EIO;
205 
206         skb_pull(skb, sizeof(u8));
207 
208         return 0;
209 }
210 
211 static struct sk_buff *
212 digital_send_dep_data_prep(struct nfc_digital_dev *ddev, struct sk_buff *skb,
213                            struct digital_dep_req_res *dep_req_res,
214                            struct digital_data_exch *data_exch)
215 {
216         struct sk_buff *new_skb;
217 
218         if (skb->len > ddev->remote_payload_max) {
219                 dep_req_res->pfb |= DIGITAL_NFC_DEP_PFB_MI_BIT;
220 
221                 new_skb = digital_skb_alloc(ddev, ddev->remote_payload_max);
222                 if (!new_skb) {
223                         kfree_skb(ddev->chaining_skb);
224                         ddev->chaining_skb = NULL;
225 
226                         return ERR_PTR(-ENOMEM);
227                 }
228 
229                 skb_put_data(new_skb, skb->data, ddev->remote_payload_max);
230                 skb_pull(skb, ddev->remote_payload_max);
231 
232                 ddev->chaining_skb = skb;
233                 ddev->data_exch = data_exch;
234         } else {
235                 ddev->chaining_skb = NULL;
236                 new_skb = skb;
237         }
238 
239         return new_skb;
240 }
241 
242 static struct sk_buff *
243 digital_recv_dep_data_gather(struct nfc_digital_dev *ddev, u8 pfb,
244                              struct sk_buff *resp,
245                              int (*send_ack)(struct nfc_digital_dev *ddev,
246                                              struct digital_data_exch
247                                                              *data_exch),
248                              struct digital_data_exch *data_exch)
249 {
250         struct sk_buff *new_skb;
251         int rc;
252 
253         if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb) && (!ddev->chaining_skb)) {
254                 ddev->chaining_skb =
255                         nfc_alloc_recv_skb(8 * ddev->local_payload_max,
256                                            GFP_KERNEL);
257                 if (!ddev->chaining_skb) {
258                         rc = -ENOMEM;
259                         goto error;
260                 }
261         }
262 
263         if (ddev->chaining_skb) {
264                 if (resp->len > skb_tailroom(ddev->chaining_skb)) {
265                         new_skb = skb_copy_expand(ddev->chaining_skb,
266                                                   skb_headroom(
267                                                           ddev->chaining_skb),
268                                                   8 * ddev->local_payload_max,
269                                                   GFP_KERNEL);
270                         if (!new_skb) {
271                                 rc = -ENOMEM;
272                                 goto error;
273                         }
274 
275                         kfree_skb(ddev->chaining_skb);
276                         ddev->chaining_skb = new_skb;
277                 }
278 
279                 skb_put_data(ddev->chaining_skb, resp->data, resp->len);
280 
281                 kfree_skb(resp);
282                 resp = NULL;
283 
284                 if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb)) {
285                         rc = send_ack(ddev, data_exch);
286                         if (rc)
287                                 goto error;
288 
289                         return NULL;
290                 }
291 
292                 resp = ddev->chaining_skb;
293                 ddev->chaining_skb = NULL;
294         }
295 
296         return resp;
297 
298 error:
299         kfree_skb(resp);
300 
301         kfree_skb(ddev->chaining_skb);
302         ddev->chaining_skb = NULL;
303 
304         return ERR_PTR(rc);
305 }
306 
307 static void digital_in_recv_psl_res(struct nfc_digital_dev *ddev, void *arg,
308                                     struct sk_buff *resp)
309 {
310         struct nfc_target *target = arg;
311         struct digital_psl_res *psl_res;
312         int rc;
313 
314         if (IS_ERR(resp)) {
315                 rc = PTR_ERR(resp);
316                 resp = NULL;
317                 goto exit;
318         }
319 
320         rc = ddev->skb_check_crc(resp);
321         if (rc) {
322                 PROTOCOL_ERR("14.4.1.6");
323                 goto exit;
324         }
325 
326         rc = digital_skb_pull_dep_sod(ddev, resp);
327         if (rc) {
328                 PROTOCOL_ERR("14.4.1.2");
329                 goto exit;
330         }
331 
332         psl_res = (struct digital_psl_res *)resp->data;
333 
334         if ((resp->len != sizeof(*psl_res)) ||
335             (psl_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN) ||
336             (psl_res->cmd != DIGITAL_CMD_PSL_RES)) {
337                 rc = -EIO;
338                 goto exit;
339         }
340 
341         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
342                                      NFC_DIGITAL_RF_TECH_424F);
343         if (rc)
344                 goto exit;
345 
346         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
347                                      NFC_DIGITAL_FRAMING_NFCF_NFC_DEP);
348         if (rc)
349                 goto exit;
350 
351         if (!DIGITAL_DRV_CAPS_IN_CRC(ddev) &&
352             (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)) {
353                 ddev->skb_add_crc = digital_skb_add_crc_f;
354                 ddev->skb_check_crc = digital_skb_check_crc_f;
355         }
356 
357         ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_424F;
358 
359         nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
360                            NFC_RF_INITIATOR);
361 
362         ddev->curr_nfc_dep_pni = 0;
363 
364 exit:
365         dev_kfree_skb(resp);
366 
367         if (rc)
368                 ddev->curr_protocol = 0;
369 }
370 
371 static int digital_in_send_psl_req(struct nfc_digital_dev *ddev,
372                                    struct nfc_target *target)
373 {
374         struct sk_buff *skb;
375         struct digital_psl_req *psl_req;
376         int rc;
377         u8 payload_size, payload_bits;
378 
379         skb = digital_skb_alloc(ddev, sizeof(*psl_req));
380         if (!skb)
381                 return -ENOMEM;
382 
383         skb_put(skb, sizeof(*psl_req));
384 
385         psl_req = (struct digital_psl_req *)skb->data;
386 
387         psl_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
388         psl_req->cmd = DIGITAL_CMD_PSL_REQ;
389         psl_req->did = 0;
390         psl_req->brs = (0x2 << 3) | 0x2; /* 424F both directions */
391 
392         payload_size = min(ddev->local_payload_max, ddev->remote_payload_max);
393         payload_bits = digital_payload_size_to_bits(payload_size);
394         psl_req->fsl = DIGITAL_PAYLOAD_BITS_TO_FSL(payload_bits);
395 
396         ddev->local_payload_max = payload_size;
397         ddev->remote_payload_max = payload_size;
398 
399         digital_skb_push_dep_sod(ddev, skb);
400 
401         ddev->skb_add_crc(skb);
402 
403         rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt,
404                                  digital_in_recv_psl_res, target);
405         if (rc)
406                 kfree_skb(skb);
407 
408         return rc;
409 }
410 
411 static void digital_in_recv_atr_res(struct nfc_digital_dev *ddev, void *arg,
412                                  struct sk_buff *resp)
413 {
414         struct nfc_target *target = arg;
415         struct digital_atr_res *atr_res;
416         u8 gb_len, payload_bits;
417         u8 wt;
418         int rc;
419 
420         if (IS_ERR(resp)) {
421                 rc = PTR_ERR(resp);
422                 resp = NULL;
423                 goto exit;
424         }
425 
426         rc = ddev->skb_check_crc(resp);
427         if (rc) {
428                 PROTOCOL_ERR("14.4.1.6");
429                 goto exit;
430         }
431 
432         rc = digital_skb_pull_dep_sod(ddev, resp);
433         if (rc) {
434                 PROTOCOL_ERR("14.4.1.2");
435                 goto exit;
436         }
437 
438         if (resp->len < sizeof(struct digital_atr_res)) {
439                 rc = -EIO;
440                 goto exit;
441         }
442 
443         gb_len = resp->len - sizeof(struct digital_atr_res);
444 
445         atr_res = (struct digital_atr_res *)resp->data;
446 
447         wt = DIGITAL_ATR_RES_TO_WT(atr_res->to);
448         if (wt > DIGITAL_NFC_DEP_IN_MAX_WT)
449                 wt = DIGITAL_NFC_DEP_IN_MAX_WT;
450         ddev->dep_rwt = digital_rwt_map[wt];
451 
452         payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_res->pp);
453         ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
454 
455         if (!ddev->remote_payload_max) {
456                 rc = -EINVAL;
457                 goto exit;
458         }
459 
460         rc = nfc_set_remote_general_bytes(ddev->nfc_dev, atr_res->gb, gb_len);
461         if (rc)
462                 goto exit;
463 
464         if ((ddev->protocols & NFC_PROTO_FELICA_MASK) &&
465             (ddev->curr_rf_tech != NFC_DIGITAL_RF_TECH_424F)) {
466                 rc = digital_in_send_psl_req(ddev, target);
467                 if (!rc)
468                         goto exit;
469         }
470 
471         rc = nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
472                                 NFC_RF_INITIATOR);
473 
474         ddev->curr_nfc_dep_pni = 0;
475 
476 exit:
477         dev_kfree_skb(resp);
478 
479         if (rc)
480                 ddev->curr_protocol = 0;
481 }
482 
483 int digital_in_send_atr_req(struct nfc_digital_dev *ddev,
484                             struct nfc_target *target, __u8 comm_mode, __u8 *gb,
485                             size_t gb_len)
486 {
487         struct sk_buff *skb;
488         struct digital_atr_req *atr_req;
489         uint size;
490         int rc;
491         u8 payload_bits;
492 
493         size = DIGITAL_ATR_REQ_MIN_SIZE + gb_len;
494 
495         if (size > DIGITAL_ATR_REQ_MAX_SIZE) {
496                 PROTOCOL_ERR("14.6.1.1");
497                 return -EINVAL;
498         }
499 
500         skb = digital_skb_alloc(ddev, size);
501         if (!skb)
502                 return -ENOMEM;
503 
504         skb_put(skb, sizeof(struct digital_atr_req));
505 
506         atr_req = (struct digital_atr_req *)skb->data;
507         memset(atr_req, 0, sizeof(struct digital_atr_req));
508 
509         atr_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
510         atr_req->cmd = DIGITAL_CMD_ATR_REQ;
511         if (target->nfcid2_len)
512                 memcpy(atr_req->nfcid3, target->nfcid2, NFC_NFCID2_MAXSIZE);
513         else
514                 get_random_bytes(atr_req->nfcid3, NFC_NFCID3_MAXSIZE);
515 
516         atr_req->did = 0;
517         atr_req->bs = 0;
518         atr_req->br = 0;
519 
520         ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX;
521         payload_bits = digital_payload_size_to_bits(ddev->local_payload_max);
522         atr_req->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits);
523 
524         if (gb_len) {
525                 atr_req->pp |= DIGITAL_GB_BIT;
526                 skb_put_data(skb, gb, gb_len);
527         }
528 
529         digital_skb_push_dep_sod(ddev, skb);
530 
531         ddev->skb_add_crc(skb);
532 
533         rc = digital_in_send_cmd(ddev, skb, DIGITAL_ATR_RES_RWT,
534                                  digital_in_recv_atr_res, target);
535         if (rc)
536                 kfree_skb(skb);
537 
538         return rc;
539 }
540 
541 static int digital_in_send_ack(struct nfc_digital_dev *ddev,
542                                struct digital_data_exch *data_exch)
543 {
544         struct digital_dep_req_res *dep_req;
545         struct sk_buff *skb;
546         int rc;
547 
548         skb = digital_skb_alloc(ddev, 1);
549         if (!skb)
550                 return -ENOMEM;
551 
552         skb_push(skb, sizeof(struct digital_dep_req_res));
553 
554         dep_req = (struct digital_dep_req_res *)skb->data;
555 
556         dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
557         dep_req->cmd = DIGITAL_CMD_DEP_REQ;
558         dep_req->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
559                        ddev->curr_nfc_dep_pni;
560 
561         digital_skb_push_dep_sod(ddev, skb);
562 
563         ddev->skb_add_crc(skb);
564 
565         ddev->saved_skb = pskb_copy(skb, GFP_KERNEL);
566 
567         rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt,
568                                  digital_in_recv_dep_res, data_exch);
569         if (rc) {
570                 kfree_skb(skb);
571                 kfree_skb(ddev->saved_skb);
572                 ddev->saved_skb = NULL;
573         }
574 
575         return rc;
576 }
577 
578 static int digital_in_send_nack(struct nfc_digital_dev *ddev,
579                                 struct digital_data_exch *data_exch)
580 {
581         struct digital_dep_req_res *dep_req;
582         struct sk_buff *skb;
583         int rc;
584 
585         skb = digital_skb_alloc(ddev, 1);
586         if (!skb)
587                 return -ENOMEM;
588 
589         skb_push(skb, sizeof(struct digital_dep_req_res));
590 
591         dep_req = (struct digital_dep_req_res *)skb->data;
592 
593         dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
594         dep_req->cmd = DIGITAL_CMD_DEP_REQ;
595         dep_req->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
596                        DIGITAL_NFC_DEP_PFB_NACK_BIT | ddev->curr_nfc_dep_pni;
597 
598         digital_skb_push_dep_sod(ddev, skb);
599 
600         ddev->skb_add_crc(skb);
601 
602         rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt,
603                                  digital_in_recv_dep_res, data_exch);
604         if (rc)
605                 kfree_skb(skb);
606 
607         return rc;
608 }
609 
610 static int digital_in_send_atn(struct nfc_digital_dev *ddev,
611                                struct digital_data_exch *data_exch)
612 {
613         struct digital_dep_req_res *dep_req;
614         struct sk_buff *skb;
615         int rc;
616 
617         skb = digital_skb_alloc(ddev, 1);
618         if (!skb)
619                 return -ENOMEM;
620 
621         skb_push(skb, sizeof(struct digital_dep_req_res));
622 
623         dep_req = (struct digital_dep_req_res *)skb->data;
624 
625         dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
626         dep_req->cmd = DIGITAL_CMD_DEP_REQ;
627         dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU;
628 
629         digital_skb_push_dep_sod(ddev, skb);
630 
631         ddev->skb_add_crc(skb);
632 
633         rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt,
634                                  digital_in_recv_dep_res, data_exch);
635         if (rc)
636                 kfree_skb(skb);
637 
638         return rc;
639 }
640 
641 static int digital_in_send_rtox(struct nfc_digital_dev *ddev,
642                                 struct digital_data_exch *data_exch, u8 rtox)
643 {
644         struct digital_dep_req_res *dep_req;
645         struct sk_buff *skb;
646         int rc;
647         u16 rwt_int;
648 
649         rwt_int = ddev->dep_rwt * rtox;
650         if (rwt_int > digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT])
651                 rwt_int = digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT];
652 
653         skb = digital_skb_alloc(ddev, 1);
654         if (!skb)
655                 return -ENOMEM;
656 
657         skb_put_u8(skb, rtox);
658 
659         skb_push(skb, sizeof(struct digital_dep_req_res));
660 
661         dep_req = (struct digital_dep_req_res *)skb->data;
662 
663         dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
664         dep_req->cmd = DIGITAL_CMD_DEP_REQ;
665         dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU |
666                        DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT;
667 
668         digital_skb_push_dep_sod(ddev, skb);
669 
670         ddev->skb_add_crc(skb);
671 
672         rc = digital_in_send_cmd(ddev, skb, rwt_int,
673                                  digital_in_recv_dep_res, data_exch);
674         if (rc)
675                 kfree_skb(skb);
676 
677         return rc;
678 }
679 
680 static int digital_in_send_saved_skb(struct nfc_digital_dev *ddev,
681                                      struct digital_data_exch *data_exch)
682 {
683         int rc;
684 
685         if (!ddev->saved_skb)
686                 return -EINVAL;
687 
688         skb_get(ddev->saved_skb);
689 
690         rc = digital_in_send_cmd(ddev, ddev->saved_skb, ddev->dep_rwt,
691                                  digital_in_recv_dep_res, data_exch);
692         if (rc)
693                 kfree_skb(ddev->saved_skb);
694 
695         return rc;
696 }
697 
698 static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
699                                     struct sk_buff *resp)
700 {
701         struct digital_data_exch *data_exch = arg;
702         struct digital_dep_req_res *dep_res;
703         u8 pfb;
704         uint size;
705         int rc;
706         u8 rtox;
707 
708         if (IS_ERR(resp)) {
709                 rc = PTR_ERR(resp);
710                 resp = NULL;
711 
712                 if ((rc == -EIO || (rc == -ETIMEDOUT && ddev->nack_count)) &&
713                     (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) {
714                         ddev->atn_count = 0;
715 
716                         rc = digital_in_send_nack(ddev, data_exch);
717                         if (rc)
718                                 goto error;
719 
720                         return;
721                 } else if ((rc == -ETIMEDOUT) &&
722                            (ddev->atn_count++ < DIGITAL_NFC_DEP_N_RETRY_ATN)) {
723                         ddev->nack_count = 0;
724 
725                         rc = digital_in_send_atn(ddev, data_exch);
726                         if (rc)
727                                 goto error;
728 
729                         return;
730                 }
731 
732                 goto exit;
733         }
734 
735         rc = digital_skb_pull_dep_sod(ddev, resp);
736         if (rc) {
737                 PROTOCOL_ERR("14.4.1.2");
738                 goto exit;
739         }
740 
741         rc = ddev->skb_check_crc(resp);
742         if (rc) {
743                 if ((resp->len >= 4) &&
744                     (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) {
745                         ddev->atn_count = 0;
746 
747                         rc = digital_in_send_nack(ddev, data_exch);
748                         if (rc)
749                                 goto error;
750 
751                         kfree_skb(resp);
752 
753                         return;
754                 }
755 
756                 PROTOCOL_ERR("14.4.1.6");
757                 goto error;
758         }
759 
760         ddev->atn_count = 0;
761         ddev->nack_count = 0;
762 
763         if (resp->len > ddev->local_payload_max) {
764                 rc = -EMSGSIZE;
765                 goto exit;
766         }
767 
768         size = sizeof(struct digital_dep_req_res);
769         dep_res = (struct digital_dep_req_res *)resp->data;
770 
771         if (resp->len < size || dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN ||
772             dep_res->cmd != DIGITAL_CMD_DEP_RES) {
773                 rc = -EIO;
774                 goto error;
775         }
776 
777         pfb = dep_res->pfb;
778 
779         if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
780                 PROTOCOL_ERR("14.8.2.1");
781                 rc = -EIO;
782                 goto error;
783         }
784 
785         if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
786                 rc = -EIO;
787                 goto exit;
788         }
789 
790         if (size > resp->len) {
791                 rc = -EIO;
792                 goto error;
793         }
794 
795         skb_pull(resp, size);
796 
797         switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
798         case DIGITAL_NFC_DEP_PFB_I_PDU:
799                 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
800                         PROTOCOL_ERR("14.12.3.3");
801                         rc = -EIO;
802                         goto error;
803                 }
804 
805                 ddev->curr_nfc_dep_pni =
806                         DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
807 
808                 kfree_skb(ddev->saved_skb);
809                 ddev->saved_skb = NULL;
810 
811                 resp = digital_recv_dep_data_gather(ddev, pfb, resp,
812                                                     digital_in_send_ack,
813                                                     data_exch);
814                 if (IS_ERR(resp)) {
815                         rc = PTR_ERR(resp);
816                         resp = NULL;
817                         goto error;
818                 }
819 
820                 /* If resp is NULL then we're still chaining so return and
821                  * wait for the next part of the PDU.  Else, the PDU is
822                  * complete so pass it up.
823                  */
824                 if (!resp)
825                         return;
826 
827                 rc = 0;
828                 break;
829 
830         case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
831                 if (DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) {
832                         PROTOCOL_ERR("14.12.4.5");
833                         rc = -EIO;
834                         goto exit;
835                 }
836 
837                 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
838                         PROTOCOL_ERR("14.12.3.3");
839                         rc = -EIO;
840                         goto exit;
841                 }
842 
843                 ddev->curr_nfc_dep_pni =
844                         DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
845 
846                 if (!ddev->chaining_skb) {
847                         PROTOCOL_ERR("14.12.4.3");
848                         rc = -EIO;
849                         goto exit;
850                 }
851 
852                 /* The initiator has received a valid ACK. Free the last sent
853                  * PDU and keep on sending chained skb.
854                  */
855                 kfree_skb(ddev->saved_skb);
856                 ddev->saved_skb = NULL;
857 
858                 rc = digital_in_send_dep_req(ddev, NULL,
859                                              ddev->chaining_skb,
860                                              ddev->data_exch);
861                 if (rc)
862                         goto error;
863 
864                 goto free_resp;
865 
866         case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
867                 if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) { /* ATN */
868                         rc = digital_in_send_saved_skb(ddev, data_exch);
869                         if (rc)
870                                 goto error;
871 
872                         goto free_resp;
873                 }
874 
875                 if (ddev->atn_count || ddev->nack_count) {
876                         PROTOCOL_ERR("14.12.4.4");
877                         rc = -EIO;
878                         goto error;
879                 }
880 
881                 rtox = DIGITAL_NFC_DEP_RTOX_VALUE(resp->data[0]);
882                 if (!rtox || rtox > DIGITAL_NFC_DEP_RTOX_MAX) {
883                         PROTOCOL_ERR("14.8.4.1");
884                         rc = -EIO;
885                         goto error;
886                 }
887 
888                 rc = digital_in_send_rtox(ddev, data_exch, rtox);
889                 if (rc)
890                         goto error;
891 
892                 goto free_resp;
893         }
894 
895 exit:
896         data_exch->cb(data_exch->cb_context, resp, rc);
897 
898 error:
899         kfree(data_exch);
900 
901         kfree_skb(ddev->chaining_skb);
902         ddev->chaining_skb = NULL;
903 
904         kfree_skb(ddev->saved_skb);
905         ddev->saved_skb = NULL;
906 
907         if (rc)
908                 kfree_skb(resp);
909 
910         return;
911 
912 free_resp:
913         dev_kfree_skb(resp);
914 }
915 
916 int digital_in_send_dep_req(struct nfc_digital_dev *ddev,
917                             struct nfc_target *target, struct sk_buff *skb,
918                             struct digital_data_exch *data_exch)
919 {
920         struct digital_dep_req_res *dep_req;
921         struct sk_buff *chaining_skb, *tmp_skb;
922         int rc;
923 
924         skb_push(skb, sizeof(struct digital_dep_req_res));
925 
926         dep_req = (struct digital_dep_req_res *)skb->data;
927 
928         dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
929         dep_req->cmd = DIGITAL_CMD_DEP_REQ;
930         dep_req->pfb = ddev->curr_nfc_dep_pni;
931 
932         ddev->atn_count = 0;
933         ddev->nack_count = 0;
934 
935         chaining_skb = ddev->chaining_skb;
936 
937         tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_req, data_exch);
938         if (IS_ERR(tmp_skb))
939                 return PTR_ERR(tmp_skb);
940 
941         digital_skb_push_dep_sod(ddev, tmp_skb);
942 
943         ddev->skb_add_crc(tmp_skb);
944 
945         ddev->saved_skb = pskb_copy(tmp_skb, GFP_KERNEL);
946 
947         rc = digital_in_send_cmd(ddev, tmp_skb, ddev->dep_rwt,
948                                  digital_in_recv_dep_res, data_exch);
949         if (rc) {
950                 if (tmp_skb != skb)
951                         kfree_skb(tmp_skb);
952 
953                 kfree_skb(chaining_skb);
954                 ddev->chaining_skb = NULL;
955 
956                 kfree_skb(ddev->saved_skb);
957                 ddev->saved_skb = NULL;
958         }
959 
960         return rc;
961 }
962 
963 static void digital_tg_set_rf_tech(struct nfc_digital_dev *ddev, u8 rf_tech)
964 {
965         ddev->curr_rf_tech = rf_tech;
966 
967         ddev->skb_add_crc = digital_skb_add_crc_none;
968         ddev->skb_check_crc = digital_skb_check_crc_none;
969 
970         if (DIGITAL_DRV_CAPS_TG_CRC(ddev))
971                 return;
972 
973         switch (ddev->curr_rf_tech) {
974         case NFC_DIGITAL_RF_TECH_106A:
975                 ddev->skb_add_crc = digital_skb_add_crc_a;
976                 ddev->skb_check_crc = digital_skb_check_crc_a;
977                 break;
978 
979         case NFC_DIGITAL_RF_TECH_212F:
980         case NFC_DIGITAL_RF_TECH_424F:
981                 ddev->skb_add_crc = digital_skb_add_crc_f;
982                 ddev->skb_check_crc = digital_skb_check_crc_f;
983                 break;
984 
985         default:
986                 break;
987         }
988 }
989 
990 static int digital_tg_send_ack(struct nfc_digital_dev *ddev,
991                                struct digital_data_exch *data_exch)
992 {
993         struct digital_dep_req_res *dep_res;
994         struct sk_buff *skb;
995         int rc;
996 
997         skb = digital_skb_alloc(ddev, 1);
998         if (!skb)
999                 return -ENOMEM;
1000 
1001         skb_push(skb, sizeof(struct digital_dep_req_res));
1002 
1003         dep_res = (struct digital_dep_req_res *)skb->data;
1004 
1005         dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1006         dep_res->cmd = DIGITAL_CMD_DEP_RES;
1007         dep_res->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
1008                        ddev->curr_nfc_dep_pni;
1009 
1010         if (ddev->did) {
1011                 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
1012 
1013                 skb_put_data(skb, &ddev->did, sizeof(ddev->did));
1014         }
1015 
1016         ddev->curr_nfc_dep_pni =
1017                 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
1018 
1019         digital_skb_push_dep_sod(ddev, skb);
1020 
1021         ddev->skb_add_crc(skb);
1022 
1023         ddev->saved_skb = pskb_copy(skb, GFP_KERNEL);
1024 
1025         rc = digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
1026                                  data_exch);
1027         if (rc) {
1028                 kfree_skb(skb);
1029                 kfree_skb(ddev->saved_skb);
1030                 ddev->saved_skb = NULL;
1031         }
1032 
1033         return rc;
1034 }
1035 
1036 static int digital_tg_send_atn(struct nfc_digital_dev *ddev)
1037 {
1038         struct digital_dep_req_res *dep_res;
1039         struct sk_buff *skb;
1040         int rc;
1041 
1042         skb = digital_skb_alloc(ddev, 1);
1043         if (!skb)
1044                 return -ENOMEM;
1045 
1046         skb_push(skb, sizeof(struct digital_dep_req_res));
1047 
1048         dep_res = (struct digital_dep_req_res *)skb->data;
1049 
1050         dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1051         dep_res->cmd = DIGITAL_CMD_DEP_RES;
1052         dep_res->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU;
1053 
1054         if (ddev->did) {
1055                 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
1056 
1057                 skb_put_data(skb, &ddev->did, sizeof(ddev->did));
1058         }
1059 
1060         digital_skb_push_dep_sod(ddev, skb);
1061 
1062         ddev->skb_add_crc(skb);
1063 
1064         rc = digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
1065                                  NULL);
1066         if (rc)
1067                 kfree_skb(skb);
1068 
1069         return rc;
1070 }
1071 
1072 static int digital_tg_send_saved_skb(struct nfc_digital_dev *ddev)
1073 {
1074         int rc;
1075 
1076         if (!ddev->saved_skb)
1077                 return -EINVAL;
1078 
1079         skb_get(ddev->saved_skb);
1080 
1081         rc = digital_tg_send_cmd(ddev, ddev->saved_skb, 1500,
1082                                  digital_tg_recv_dep_req, NULL);
1083         if (rc)
1084                 kfree_skb(ddev->saved_skb);
1085 
1086         return rc;
1087 }
1088 
1089 static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
1090                                     struct sk_buff *resp)
1091 {
1092         int rc;
1093         struct digital_dep_req_res *dep_req;
1094         u8 pfb;
1095         size_t size;
1096 
1097         if (IS_ERR(resp)) {
1098                 rc = PTR_ERR(resp);
1099                 resp = NULL;
1100                 goto exit;
1101         }
1102 
1103         rc = ddev->skb_check_crc(resp);
1104         if (rc) {
1105                 PROTOCOL_ERR("14.4.1.6");
1106                 goto exit;
1107         }
1108 
1109         rc = digital_skb_pull_dep_sod(ddev, resp);
1110         if (rc) {
1111                 PROTOCOL_ERR("14.4.1.2");
1112                 goto exit;
1113         }
1114 
1115         if (resp->len > ddev->local_payload_max) {
1116                 rc = -EMSGSIZE;
1117                 goto exit;
1118         }
1119 
1120         size = sizeof(struct digital_dep_req_res);
1121         dep_req = (struct digital_dep_req_res *)resp->data;
1122 
1123         if (resp->len < size || dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1124             dep_req->cmd != DIGITAL_CMD_DEP_REQ) {
1125                 rc = -EIO;
1126                 goto exit;
1127         }
1128 
1129         pfb = dep_req->pfb;
1130 
1131         if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
1132                 if (ddev->did && (ddev->did == resp->data[3])) {
1133                         size++;
1134                 } else {
1135                         rc = -EIO;
1136                         goto exit;
1137                 }
1138         } else if (ddev->did) {
1139                 rc = -EIO;
1140                 goto exit;
1141         }
1142 
1143         if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
1144                 rc = -EIO;
1145                 goto exit;
1146         }
1147 
1148         if (size > resp->len) {
1149                 rc = -EIO;
1150                 goto exit;
1151         }
1152 
1153         skb_pull(resp, size);
1154 
1155         switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
1156         case DIGITAL_NFC_DEP_PFB_I_PDU:
1157                 pr_debug("DIGITAL_NFC_DEP_PFB_I_PDU\n");
1158 
1159                 if (ddev->atn_count) {
1160                         /* The target has received (and replied to) at least one
1161                          * ATN DEP_REQ.
1162                          */
1163                         ddev->atn_count = 0;
1164 
1165                         /* pni of resp PDU equal to the target current pni - 1
1166                          * means resp is the previous DEP_REQ PDU received from
1167                          * the initiator so the target replies with saved_skb
1168                          * which is the previous DEP_RES saved in
1169                          * digital_tg_send_dep_res().
1170                          */
1171                         if (DIGITAL_NFC_DEP_PFB_PNI(pfb) ==
1172                           DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni - 1)) {
1173                                 rc = digital_tg_send_saved_skb(ddev);
1174                                 if (rc)
1175                                         goto exit;
1176 
1177                                 goto free_resp;
1178                         }
1179 
1180                         /* atn_count > 0 and PDU pni != curr_nfc_dep_pni - 1
1181                          * means the target probably did not received the last
1182                          * DEP_REQ PDU sent by the initiator. The target
1183                          * fallbacks to normal processing then.
1184                          */
1185                 }
1186 
1187                 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
1188                         PROTOCOL_ERR("14.12.3.4");
1189                         rc = -EIO;
1190                         goto exit;
1191                 }
1192 
1193                 kfree_skb(ddev->saved_skb);
1194                 ddev->saved_skb = NULL;
1195 
1196                 resp = digital_recv_dep_data_gather(ddev, pfb, resp,
1197                                                     digital_tg_send_ack, NULL);
1198                 if (IS_ERR(resp)) {
1199                         rc = PTR_ERR(resp);
1200                         resp = NULL;
1201                         goto exit;
1202                 }
1203 
1204                 /* If resp is NULL then we're still chaining so return and
1205                  * wait for the next part of the PDU.  Else, the PDU is
1206                  * complete so pass it up.
1207                  */
1208                 if (!resp)
1209                         return;
1210 
1211                 rc = 0;
1212                 break;
1213         case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
1214                 if (DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) { /* NACK */
1215                         if (DIGITAL_NFC_DEP_PFB_PNI(pfb + 1) !=
1216                                                 ddev->curr_nfc_dep_pni) {
1217                                 rc = -EIO;
1218                                 goto exit;
1219                         }
1220 
1221                         ddev->atn_count = 0;
1222 
1223                         rc = digital_tg_send_saved_skb(ddev);
1224                         if (rc)
1225                                 goto exit;
1226 
1227                         goto free_resp;
1228                 }
1229 
1230                 /* ACK */
1231                 if (ddev->atn_count) {
1232                         /* The target has previously recevied one or more ATN
1233                          * PDUs.
1234                          */
1235                         ddev->atn_count = 0;
1236 
1237                         /* If the ACK PNI is equal to the target PNI - 1 means
1238                          * that the initiator did not receive the previous PDU
1239                          * sent by the target so re-send it.
1240                          */
1241                         if (DIGITAL_NFC_DEP_PFB_PNI(pfb + 1) ==
1242                                                 ddev->curr_nfc_dep_pni) {
1243                                 rc = digital_tg_send_saved_skb(ddev);
1244                                 if (rc)
1245                                         goto exit;
1246 
1247                                 goto free_resp;
1248                         }
1249 
1250                         /* Otherwise, the target did not receive the previous
1251                          * ACK PDU from the initiator. Fallback to normal
1252                          * processing of chained PDU then.
1253                          */
1254                 }
1255 
1256                 /* Keep on sending chained PDU */
1257                 if (!ddev->chaining_skb ||
1258                     DIGITAL_NFC_DEP_PFB_PNI(pfb) !=
1259                                         ddev->curr_nfc_dep_pni) {
1260                         rc = -EIO;
1261                         goto exit;
1262                 }
1263 
1264                 kfree_skb(ddev->saved_skb);
1265                 ddev->saved_skb = NULL;
1266 
1267                 rc = digital_tg_send_dep_res(ddev, ddev->chaining_skb);
1268                 if (rc)
1269                         goto exit;
1270 
1271                 goto free_resp;
1272         case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
1273                 if (DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) {
1274                         rc = -EINVAL;
1275                         goto exit;
1276                 }
1277 
1278                 rc = digital_tg_send_atn(ddev);
1279                 if (rc)
1280                         goto exit;
1281 
1282                 ddev->atn_count++;
1283 
1284                 goto free_resp;
1285         }
1286 
1287         rc = nfc_tm_data_received(ddev->nfc_dev, resp);
1288 
1289 exit:
1290         kfree_skb(ddev->chaining_skb);
1291         ddev->chaining_skb = NULL;
1292 
1293         ddev->atn_count = 0;
1294 
1295         kfree_skb(ddev->saved_skb);
1296         ddev->saved_skb = NULL;
1297 
1298         if (rc)
1299                 kfree_skb(resp);
1300 
1301         return;
1302 
1303 free_resp:
1304         dev_kfree_skb(resp);
1305 }
1306 
1307 int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb)
1308 {
1309         struct digital_dep_req_res *dep_res;
1310         struct sk_buff *chaining_skb, *tmp_skb;
1311         int rc;
1312 
1313         skb_push(skb, sizeof(struct digital_dep_req_res));
1314 
1315         dep_res = (struct digital_dep_req_res *)skb->data;
1316 
1317         dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1318         dep_res->cmd = DIGITAL_CMD_DEP_RES;
1319         dep_res->pfb = ddev->curr_nfc_dep_pni;
1320 
1321         if (ddev->did) {
1322                 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
1323 
1324                 skb_put_data(skb, &ddev->did, sizeof(ddev->did));
1325         }
1326 
1327         ddev->curr_nfc_dep_pni =
1328                 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
1329 
1330         chaining_skb = ddev->chaining_skb;
1331 
1332         tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_res, NULL);
1333         if (IS_ERR(tmp_skb))
1334                 return PTR_ERR(tmp_skb);
1335 
1336         digital_skb_push_dep_sod(ddev, tmp_skb);
1337 
1338         ddev->skb_add_crc(tmp_skb);
1339 
1340         ddev->saved_skb = pskb_copy(tmp_skb, GFP_KERNEL);
1341 
1342         rc = digital_tg_send_cmd(ddev, tmp_skb, 1500, digital_tg_recv_dep_req,
1343                                  NULL);
1344         if (rc) {
1345                 if (tmp_skb != skb)
1346                         kfree_skb(tmp_skb);
1347 
1348                 kfree_skb(chaining_skb);
1349                 ddev->chaining_skb = NULL;
1350 
1351                 kfree_skb(ddev->saved_skb);
1352                 ddev->saved_skb = NULL;
1353         }
1354 
1355         return rc;
1356 }
1357 
1358 static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev,
1359                                              void *arg, struct sk_buff *resp)
1360 {
1361         u8 rf_tech = (unsigned long)arg;
1362 
1363         if (IS_ERR(resp))
1364                 return;
1365 
1366         digital_tg_set_rf_tech(ddev, rf_tech);
1367 
1368         digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
1369 
1370         digital_tg_listen(ddev, 1500, digital_tg_recv_dep_req, NULL);
1371 
1372         dev_kfree_skb(resp);
1373 }
1374 
1375 static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did,
1376                                    u8 rf_tech)
1377 {
1378         struct digital_psl_res *psl_res;
1379         struct sk_buff *skb;
1380         int rc;
1381 
1382         skb = digital_skb_alloc(ddev, sizeof(struct digital_psl_res));
1383         if (!skb)
1384                 return -ENOMEM;
1385 
1386         skb_put(skb, sizeof(struct digital_psl_res));
1387 
1388         psl_res = (struct digital_psl_res *)skb->data;
1389 
1390         psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1391         psl_res->cmd = DIGITAL_CMD_PSL_RES;
1392         psl_res->did = did;
1393 
1394         digital_skb_push_dep_sod(ddev, skb);
1395 
1396         ddev->skb_add_crc(skb);
1397 
1398         ddev->curr_nfc_dep_pni = 0;
1399 
1400         rc = digital_tg_send_cmd(ddev, skb, 0, digital_tg_send_psl_res_complete,
1401                                  (void *)(unsigned long)rf_tech);
1402         if (rc)
1403                 kfree_skb(skb);
1404 
1405         return rc;
1406 }
1407 
1408 static void digital_tg_recv_psl_req(struct nfc_digital_dev *ddev, void *arg,
1409                                     struct sk_buff *resp)
1410 {
1411         int rc;
1412         struct digital_psl_req *psl_req;
1413         u8 rf_tech;
1414         u8 dsi, payload_size, payload_bits;
1415 
1416         if (IS_ERR(resp)) {
1417                 rc = PTR_ERR(resp);
1418                 resp = NULL;
1419                 goto exit;
1420         }
1421 
1422         rc = ddev->skb_check_crc(resp);
1423         if (rc) {
1424                 PROTOCOL_ERR("14.4.1.6");
1425                 goto exit;
1426         }
1427 
1428         rc = digital_skb_pull_dep_sod(ddev, resp);
1429         if (rc) {
1430                 PROTOCOL_ERR("14.4.1.2");
1431                 goto exit;
1432         }
1433 
1434         psl_req = (struct digital_psl_req *)resp->data;
1435 
1436         if (resp->len != sizeof(struct digital_psl_req) ||
1437             psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1438             psl_req->cmd != DIGITAL_CMD_PSL_REQ) {
1439                 rc = -EIO;
1440                 goto exit;
1441         }
1442 
1443         dsi = (psl_req->brs >> 3) & 0x07;
1444         switch (dsi) {
1445         case 0:
1446                 rf_tech = NFC_DIGITAL_RF_TECH_106A;
1447                 break;
1448         case 1:
1449                 rf_tech = NFC_DIGITAL_RF_TECH_212F;
1450                 break;
1451         case 2:
1452                 rf_tech = NFC_DIGITAL_RF_TECH_424F;
1453                 break;
1454         default:
1455                 pr_err("Unsupported dsi value %d\n", dsi);
1456                 goto exit;
1457         }
1458 
1459         payload_bits = DIGITAL_PAYLOAD_FSL_TO_BITS(psl_req->fsl);
1460         payload_size = digital_payload_bits_to_size(payload_bits);
1461 
1462         if (!payload_size || (payload_size > min(ddev->local_payload_max,
1463                                                  ddev->remote_payload_max))) {
1464                 rc = -EINVAL;
1465                 goto exit;
1466         }
1467 
1468         ddev->local_payload_max = payload_size;
1469         ddev->remote_payload_max = payload_size;
1470 
1471         rc = digital_tg_send_psl_res(ddev, psl_req->did, rf_tech);
1472 
1473 exit:
1474         kfree_skb(resp);
1475 }
1476 
1477 static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev,
1478                                              void *arg, struct sk_buff *resp)
1479 {
1480         int offset;
1481 
1482         if (IS_ERR(resp)) {
1483                 digital_poll_next_tech(ddev);
1484                 return;
1485         }
1486 
1487         offset = 2;
1488         if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB)
1489                 offset++;
1490 
1491         ddev->atn_count = 0;
1492 
1493         if (resp->data[offset] == DIGITAL_CMD_PSL_REQ)
1494                 digital_tg_recv_psl_req(ddev, arg, resp);
1495         else
1496                 digital_tg_recv_dep_req(ddev, arg, resp);
1497 }
1498 
1499 static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev,
1500                                    struct digital_atr_req *atr_req)
1501 {
1502         struct digital_atr_res *atr_res;
1503         struct sk_buff *skb;
1504         u8 *gb, payload_bits;
1505         size_t gb_len;
1506         int rc;
1507 
1508         gb = nfc_get_local_general_bytes(ddev->nfc_dev, &gb_len);
1509         if (!gb)
1510                 gb_len = 0;
1511 
1512         skb = digital_skb_alloc(ddev, sizeof(struct digital_atr_res) + gb_len);
1513         if (!skb)
1514                 return -ENOMEM;
1515 
1516         skb_put(skb, sizeof(struct digital_atr_res));
1517         atr_res = (struct digital_atr_res *)skb->data;
1518 
1519         memset(atr_res, 0, sizeof(struct digital_atr_res));
1520 
1521         atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1522         atr_res->cmd = DIGITAL_CMD_ATR_RES;
1523         memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3));
1524         atr_res->to = DIGITAL_NFC_DEP_TG_MAX_WT;
1525 
1526         ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX;
1527         payload_bits = digital_payload_size_to_bits(ddev->local_payload_max);
1528         atr_res->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits);
1529 
1530         if (gb_len) {
1531                 skb_put(skb, gb_len);
1532 
1533                 atr_res->pp |= DIGITAL_GB_BIT;
1534                 memcpy(atr_res->gb, gb, gb_len);
1535         }
1536 
1537         digital_skb_push_dep_sod(ddev, skb);
1538 
1539         ddev->skb_add_crc(skb);
1540 
1541         ddev->curr_nfc_dep_pni = 0;
1542 
1543         rc = digital_tg_send_cmd(ddev, skb, 999,
1544                                  digital_tg_send_atr_res_complete, NULL);
1545         if (rc)
1546                 kfree_skb(skb);
1547 
1548         return rc;
1549 }
1550 
1551 void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg,
1552                              struct sk_buff *resp)
1553 {
1554         int rc;
1555         struct digital_atr_req *atr_req;
1556         size_t gb_len, min_size;
1557         u8 poll_tech_count, payload_bits;
1558 
1559         if (IS_ERR(resp)) {
1560                 rc = PTR_ERR(resp);
1561                 resp = NULL;
1562                 goto exit;
1563         }
1564 
1565         if (!resp->len) {
1566                 rc = -EIO;
1567                 goto exit;
1568         }
1569 
1570         if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) {
1571                 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2;
1572                 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_106A);
1573         } else {
1574                 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1;
1575                 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_212F);
1576         }
1577 
1578         if (resp->len < min_size) {
1579                 rc = -EIO;
1580                 goto exit;
1581         }
1582 
1583         ddev->curr_protocol = NFC_PROTO_NFC_DEP_MASK;
1584 
1585         rc = ddev->skb_check_crc(resp);
1586         if (rc) {
1587                 PROTOCOL_ERR("14.4.1.6");
1588                 goto exit;
1589         }
1590 
1591         rc = digital_skb_pull_dep_sod(ddev, resp);
1592         if (rc) {
1593                 PROTOCOL_ERR("14.4.1.2");
1594                 goto exit;
1595         }
1596 
1597         atr_req = (struct digital_atr_req *)resp->data;
1598 
1599         if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1600             atr_req->cmd != DIGITAL_CMD_ATR_REQ ||
1601             atr_req->did > DIGITAL_DID_MAX) {
1602                 rc = -EINVAL;
1603                 goto exit;
1604         }
1605 
1606         payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_req->pp);
1607         ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
1608 
1609         if (!ddev->remote_payload_max) {
1610                 rc = -EINVAL;
1611                 goto exit;
1612         }
1613 
1614         ddev->did = atr_req->did;
1615 
1616         rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1617                                      NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED);
1618         if (rc)
1619                 goto exit;
1620 
1621         rc = digital_tg_send_atr_res(ddev, atr_req);
1622         if (rc)
1623                 goto exit;
1624 
1625         gb_len = resp->len - sizeof(struct digital_atr_req);
1626 
1627         poll_tech_count = ddev->poll_tech_count;
1628         ddev->poll_tech_count = 0;
1629 
1630         rc = nfc_tm_activated(ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
1631                               NFC_COMM_PASSIVE, atr_req->gb, gb_len);
1632         if (rc) {
1633                 ddev->poll_tech_count = poll_tech_count;
1634                 goto exit;
1635         }
1636 
1637         rc = 0;
1638 exit:
1639         if (rc)
1640                 digital_poll_next_tech(ddev);
1641 
1642         dev_kfree_skb(resp);
1643 }
1644 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp