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

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

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

~ [ 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