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

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

Version: ~ [ linux-5.13-rc1 ] ~ [ linux-5.12.2 ] ~ [ linux-5.11.19 ] ~ [ linux-5.10.35 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.117 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.190 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.232 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.268 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.268 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ 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_CMD_SENS_REQ    0x26
 21 #define DIGITAL_CMD_ALL_REQ     0x52
 22 #define DIGITAL_CMD_SEL_REQ_CL1 0x93
 23 #define DIGITAL_CMD_SEL_REQ_CL2 0x95
 24 #define DIGITAL_CMD_SEL_REQ_CL3 0x97
 25 
 26 #define DIGITAL_SDD_REQ_SEL_PAR 0x20
 27 
 28 #define DIGITAL_SDD_RES_CT  0x88
 29 #define DIGITAL_SDD_RES_LEN 5
 30 #define DIGITAL_SEL_RES_LEN 1
 31 
 32 #define DIGITAL_SEL_RES_NFCID1_COMPLETE(sel_res) (!((sel_res) & 0x04))
 33 #define DIGITAL_SEL_RES_IS_T2T(sel_res) (!((sel_res) & 0x60))
 34 #define DIGITAL_SEL_RES_IS_T4T(sel_res) ((sel_res) & 0x20)
 35 #define DIGITAL_SEL_RES_IS_NFC_DEP(sel_res) ((sel_res) & 0x40)
 36 
 37 #define DIGITAL_SENS_RES_IS_T1T(sens_res) (((sens_res) & 0x0C00) == 0x0C00)
 38 #define DIGITAL_SENS_RES_IS_VALID(sens_res) \
 39         ((!((sens_res) & 0x001F) && (((sens_res) & 0x0C00) == 0x0C00)) || \
 40         (((sens_res) & 0x001F) && ((sens_res) & 0x0C00) != 0x0C00))
 41 
 42 #define DIGITAL_MIFARE_READ_RES_LEN 16
 43 #define DIGITAL_MIFARE_ACK_RES  0x0A
 44 
 45 #define DIGITAL_CMD_SENSB_REQ                   0x05
 46 #define DIGITAL_SENSB_ADVANCED                  BIT(5)
 47 #define DIGITAL_SENSB_EXTENDED                  BIT(4)
 48 #define DIGITAL_SENSB_ALLB_REQ                  BIT(3)
 49 #define DIGITAL_SENSB_N(n)                      ((n) & 0x7)
 50 
 51 #define DIGITAL_CMD_SENSB_RES                   0x50
 52 
 53 #define DIGITAL_CMD_ATTRIB_REQ                  0x1D
 54 #define DIGITAL_ATTRIB_P1_TR0_DEFAULT           (0x0 << 6)
 55 #define DIGITAL_ATTRIB_P1_TR1_DEFAULT           (0x0 << 4)
 56 #define DIGITAL_ATTRIB_P1_SUPRESS_EOS           BIT(3)
 57 #define DIGITAL_ATTRIB_P1_SUPRESS_SOS           BIT(2)
 58 #define DIGITAL_ATTRIB_P2_LISTEN_POLL_1         (0x0 << 6)
 59 #define DIGITAL_ATTRIB_P2_POLL_LISTEN_1         (0x0 << 4)
 60 #define DIGITAL_ATTRIB_P2_MAX_FRAME_256         0x8
 61 #define DIGITAL_ATTRIB_P4_DID(n)                ((n) & 0xf)
 62 
 63 #define DIGITAL_CMD_SENSF_REQ   0x00
 64 #define DIGITAL_CMD_SENSF_RES   0x01
 65 
 66 #define DIGITAL_SENSF_RES_MIN_LENGTH 17
 67 #define DIGITAL_SENSF_RES_RD_AP_B1   0x00
 68 #define DIGITAL_SENSF_RES_RD_AP_B2   0x8F
 69 
 70 #define DIGITAL_SENSF_REQ_RC_NONE 0
 71 #define DIGITAL_SENSF_REQ_RC_SC   1
 72 #define DIGITAL_SENSF_REQ_RC_AP   2
 73 
 74 #define DIGITAL_CMD_ISO15693_INVENTORY_REQ      0x01
 75 
 76 #define DIGITAL_ISO15693_REQ_FLAG_DATA_RATE     BIT(1)
 77 #define DIGITAL_ISO15693_REQ_FLAG_INVENTORY     BIT(2)
 78 #define DIGITAL_ISO15693_REQ_FLAG_NB_SLOTS      BIT(5)
 79 #define DIGITAL_ISO15693_RES_FLAG_ERROR         BIT(0)
 80 #define DIGITAL_ISO15693_RES_IS_VALID(flags) \
 81         (!((flags) & DIGITAL_ISO15693_RES_FLAG_ERROR))
 82 
 83 #define DIGITAL_ISO_DEP_I_PCB    0x02
 84 #define DIGITAL_ISO_DEP_PNI(pni) ((pni) & 0x01)
 85 
 86 #define DIGITAL_ISO_DEP_PCB_TYPE(pcb) ((pcb) & 0xC0)
 87 
 88 #define DIGITAL_ISO_DEP_I_BLOCK 0x00
 89 
 90 #define DIGITAL_ISO_DEP_BLOCK_HAS_DID(pcb) ((pcb) & 0x08)
 91 
 92 static const u8 digital_ats_fsc[] = {
 93          16,  24,  32,  40,  48,  64,  96, 128,
 94 };
 95 
 96 #define DIGITAL_ATS_FSCI(t0) ((t0) & 0x0F)
 97 #define DIGITAL_SENSB_FSCI(pi2) (((pi2) & 0xF0) >> 4)
 98 #define DIGITAL_ATS_MAX_FSC  256
 99 
100 #define DIGITAL_RATS_BYTE1 0xE0
101 #define DIGITAL_RATS_PARAM 0x80
102 
103 struct digital_sdd_res {
104         u8 nfcid1[4];
105         u8 bcc;
106 } __packed;
107 
108 struct digital_sel_req {
109         u8 sel_cmd;
110         u8 b2;
111         u8 nfcid1[4];
112         u8 bcc;
113 } __packed;
114 
115 struct digital_sensb_req {
116         u8 cmd;
117         u8 afi;
118         u8 param;
119 } __packed;
120 
121 struct digital_sensb_res {
122         u8 cmd;
123         u8 nfcid0[4];
124         u8 app_data[4];
125         u8 proto_info[3];
126 } __packed;
127 
128 struct digital_attrib_req {
129         u8 cmd;
130         u8 nfcid0[4];
131         u8 param1;
132         u8 param2;
133         u8 param3;
134         u8 param4;
135 } __packed;
136 
137 struct digital_attrib_res {
138         u8 mbli_did;
139 } __packed;
140 
141 struct digital_sensf_req {
142         u8 cmd;
143         u8 sc1;
144         u8 sc2;
145         u8 rc;
146         u8 tsn;
147 } __packed;
148 
149 struct digital_sensf_res {
150         u8 cmd;
151         u8 nfcid2[8];
152         u8 pad0[2];
153         u8 pad1[3];
154         u8 mrti_check;
155         u8 mrti_update;
156         u8 pad2;
157         u8 rd[2];
158 } __packed;
159 
160 struct digital_iso15693_inv_req {
161         u8 flags;
162         u8 cmd;
163         u8 mask_len;
164         u64 mask;
165 } __packed;
166 
167 struct digital_iso15693_inv_res {
168         u8 flags;
169         u8 dsfid;
170         u64 uid;
171 } __packed;
172 
173 static int digital_in_send_sdd_req(struct nfc_digital_dev *ddev,
174                                    struct nfc_target *target);
175 
176 int digital_in_iso_dep_pull_sod(struct nfc_digital_dev *ddev,
177                                 struct sk_buff *skb)
178 {
179         u8 pcb;
180         u8 block_type;
181 
182         if (skb->len < 1)
183                 return -EIO;
184 
185         pcb = *skb->data;
186         block_type = DIGITAL_ISO_DEP_PCB_TYPE(pcb);
187 
188         /* No support fo R-block nor S-block */
189         if (block_type != DIGITAL_ISO_DEP_I_BLOCK) {
190                 pr_err("ISO_DEP R-block and S-block not supported\n");
191                 return -EIO;
192         }
193 
194         if (DIGITAL_ISO_DEP_BLOCK_HAS_DID(pcb)) {
195                 pr_err("DID field in ISO_DEP PCB not supported\n");
196                 return -EIO;
197         }
198 
199         skb_pull(skb, 1);
200 
201         return 0;
202 }
203 
204 int digital_in_iso_dep_push_sod(struct nfc_digital_dev *ddev,
205                                 struct sk_buff *skb)
206 {
207         /*
208          * Chaining not supported so skb->len + 1 PCB byte + 2 CRC bytes must
209          * not be greater than remote FSC
210          */
211         if (skb->len + 3 > ddev->target_fsc)
212                 return -EIO;
213 
214         skb_push(skb, 1);
215 
216         *skb->data = DIGITAL_ISO_DEP_I_PCB | ddev->curr_nfc_dep_pni;
217 
218         ddev->curr_nfc_dep_pni =
219                 DIGITAL_ISO_DEP_PNI(ddev->curr_nfc_dep_pni + 1);
220 
221         return 0;
222 }
223 
224 static void digital_in_recv_ats(struct nfc_digital_dev *ddev, void *arg,
225                                 struct sk_buff *resp)
226 {
227         struct nfc_target *target = arg;
228         u8 fsdi;
229         int rc;
230 
231         if (IS_ERR(resp)) {
232                 rc = PTR_ERR(resp);
233                 resp = NULL;
234                 goto exit;
235         }
236 
237         if (resp->len < 2) {
238                 rc = -EIO;
239                 goto exit;
240         }
241 
242         fsdi = DIGITAL_ATS_FSCI(resp->data[1]);
243         if (fsdi >= 8)
244                 ddev->target_fsc = DIGITAL_ATS_MAX_FSC;
245         else
246                 ddev->target_fsc = digital_ats_fsc[fsdi];
247 
248         ddev->curr_nfc_dep_pni = 0;
249 
250         rc = digital_target_found(ddev, target, NFC_PROTO_ISO14443);
251 
252 exit:
253         dev_kfree_skb(resp);
254         kfree(target);
255 
256         if (rc)
257                 digital_poll_next_tech(ddev);
258 }
259 
260 static int digital_in_send_rats(struct nfc_digital_dev *ddev,
261                                 struct nfc_target *target)
262 {
263         int rc;
264         struct sk_buff *skb;
265 
266         skb = digital_skb_alloc(ddev, 2);
267         if (!skb)
268                 return -ENOMEM;
269 
270         skb_put_u8(skb, DIGITAL_RATS_BYTE1);
271         skb_put_u8(skb, DIGITAL_RATS_PARAM);
272 
273         rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_ats,
274                                  target);
275         if (rc)
276                 kfree_skb(skb);
277 
278         return rc;
279 }
280 
281 static void digital_in_recv_sel_res(struct nfc_digital_dev *ddev, void *arg,
282                                     struct sk_buff *resp)
283 {
284         struct nfc_target *target = arg;
285         int rc;
286         u8 sel_res;
287         u8 nfc_proto;
288 
289         if (IS_ERR(resp)) {
290                 rc = PTR_ERR(resp);
291                 resp = NULL;
292                 goto exit;
293         }
294 
295         if (!DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
296                 rc = digital_skb_check_crc_a(resp);
297                 if (rc) {
298                         PROTOCOL_ERR("4.4.1.3");
299                         goto exit;
300                 }
301         }
302 
303         if (resp->len != DIGITAL_SEL_RES_LEN) {
304                 rc = -EIO;
305                 goto exit;
306         }
307 
308         sel_res = resp->data[0];
309 
310         if (!DIGITAL_SEL_RES_NFCID1_COMPLETE(sel_res)) {
311                 rc = digital_in_send_sdd_req(ddev, target);
312                 if (rc)
313                         goto exit;
314 
315                 goto exit_free_skb;
316         }
317 
318         target->sel_res = sel_res;
319 
320         if (DIGITAL_SEL_RES_IS_T2T(sel_res)) {
321                 nfc_proto = NFC_PROTO_MIFARE;
322         } else if (DIGITAL_SEL_RES_IS_NFC_DEP(sel_res)) {
323                 nfc_proto = NFC_PROTO_NFC_DEP;
324         } else if (DIGITAL_SEL_RES_IS_T4T(sel_res)) {
325                 rc = digital_in_send_rats(ddev, target);
326                 if (rc)
327                         goto exit;
328                 /*
329                  * Skip target_found and don't free it for now. This will be
330                  * done when receiving the ATS
331                  */
332                 goto exit_free_skb;
333         } else {
334                 rc = -EOPNOTSUPP;
335                 goto exit;
336         }
337 
338         rc = digital_target_found(ddev, target, nfc_proto);
339 
340 exit:
341         kfree(target);
342 
343 exit_free_skb:
344         dev_kfree_skb(resp);
345 
346         if (rc)
347                 digital_poll_next_tech(ddev);
348 }
349 
350 static int digital_in_send_sel_req(struct nfc_digital_dev *ddev,
351                                    struct nfc_target *target,
352                                    struct digital_sdd_res *sdd_res)
353 {
354         struct sk_buff *skb;
355         struct digital_sel_req *sel_req;
356         u8 sel_cmd;
357         int rc;
358 
359         skb = digital_skb_alloc(ddev, sizeof(struct digital_sel_req));
360         if (!skb)
361                 return -ENOMEM;
362 
363         skb_put(skb, sizeof(struct digital_sel_req));
364         sel_req = (struct digital_sel_req *)skb->data;
365 
366         if (target->nfcid1_len <= 4)
367                 sel_cmd = DIGITAL_CMD_SEL_REQ_CL1;
368         else if (target->nfcid1_len < 10)
369                 sel_cmd = DIGITAL_CMD_SEL_REQ_CL2;
370         else
371                 sel_cmd = DIGITAL_CMD_SEL_REQ_CL3;
372 
373         sel_req->sel_cmd = sel_cmd;
374         sel_req->b2 = 0x70;
375         memcpy(sel_req->nfcid1, sdd_res->nfcid1, 4);
376         sel_req->bcc = sdd_res->bcc;
377 
378         if (DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
379                 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
380                                 NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A);
381                 if (rc)
382                         goto exit;
383         } else {
384                 digital_skb_add_crc_a(skb);
385         }
386 
387         rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sel_res,
388                                  target);
389 exit:
390         if (rc)
391                 kfree_skb(skb);
392 
393         return rc;
394 }
395 
396 static void digital_in_recv_sdd_res(struct nfc_digital_dev *ddev, void *arg,
397                                     struct sk_buff *resp)
398 {
399         struct nfc_target *target = arg;
400         struct digital_sdd_res *sdd_res;
401         int rc;
402         u8 offset, size;
403         u8 i, bcc;
404 
405         if (IS_ERR(resp)) {
406                 rc = PTR_ERR(resp);
407                 resp = NULL;
408                 goto exit;
409         }
410 
411         if (resp->len < DIGITAL_SDD_RES_LEN) {
412                 PROTOCOL_ERR("4.7.2.8");
413                 rc = -EINVAL;
414                 goto exit;
415         }
416 
417         sdd_res = (struct digital_sdd_res *)resp->data;
418 
419         for (i = 0, bcc = 0; i < 4; i++)
420                 bcc ^= sdd_res->nfcid1[i];
421 
422         if (bcc != sdd_res->bcc) {
423                 PROTOCOL_ERR("4.7.2.6");
424                 rc = -EINVAL;
425                 goto exit;
426         }
427 
428         if (sdd_res->nfcid1[0] == DIGITAL_SDD_RES_CT) {
429                 offset = 1;
430                 size = 3;
431         } else {
432                 offset = 0;
433                 size = 4;
434         }
435 
436         memcpy(target->nfcid1 + target->nfcid1_len, sdd_res->nfcid1 + offset,
437                size);
438         target->nfcid1_len += size;
439 
440         rc = digital_in_send_sel_req(ddev, target, sdd_res);
441 
442 exit:
443         dev_kfree_skb(resp);
444 
445         if (rc) {
446                 kfree(target);
447                 digital_poll_next_tech(ddev);
448         }
449 }
450 
451 static int digital_in_send_sdd_req(struct nfc_digital_dev *ddev,
452                                    struct nfc_target *target)
453 {
454         int rc;
455         struct sk_buff *skb;
456         u8 sel_cmd;
457 
458         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
459                                      NFC_DIGITAL_FRAMING_NFCA_STANDARD);
460         if (rc)
461                 return rc;
462 
463         skb = digital_skb_alloc(ddev, 2);
464         if (!skb)
465                 return -ENOMEM;
466 
467         if (target->nfcid1_len == 0)
468                 sel_cmd = DIGITAL_CMD_SEL_REQ_CL1;
469         else if (target->nfcid1_len == 3)
470                 sel_cmd = DIGITAL_CMD_SEL_REQ_CL2;
471         else
472                 sel_cmd = DIGITAL_CMD_SEL_REQ_CL3;
473 
474         skb_put_u8(skb, sel_cmd);
475         skb_put_u8(skb, DIGITAL_SDD_REQ_SEL_PAR);
476 
477         return digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sdd_res,
478                                    target);
479 }
480 
481 static void digital_in_recv_sens_res(struct nfc_digital_dev *ddev, void *arg,
482                                      struct sk_buff *resp)
483 {
484         struct nfc_target *target = NULL;
485         int rc;
486 
487         if (IS_ERR(resp)) {
488                 rc = PTR_ERR(resp);
489                 resp = NULL;
490                 goto exit;
491         }
492 
493         if (resp->len < sizeof(u16)) {
494                 rc = -EIO;
495                 goto exit;
496         }
497 
498         target = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
499         if (!target) {
500                 rc = -ENOMEM;
501                 goto exit;
502         }
503 
504         target->sens_res = __le16_to_cpu(*(__le16 *)resp->data);
505 
506         if (!DIGITAL_SENS_RES_IS_VALID(target->sens_res)) {
507                 PROTOCOL_ERR("4.6.3.3");
508                 rc = -EINVAL;
509                 goto exit;
510         }
511 
512         if (DIGITAL_SENS_RES_IS_T1T(target->sens_res))
513                 rc = digital_target_found(ddev, target, NFC_PROTO_JEWEL);
514         else
515                 rc = digital_in_send_sdd_req(ddev, target);
516 
517 exit:
518         dev_kfree_skb(resp);
519 
520         if (rc) {
521                 kfree(target);
522                 digital_poll_next_tech(ddev);
523         }
524 }
525 
526 int digital_in_send_sens_req(struct nfc_digital_dev *ddev, u8 rf_tech)
527 {
528         struct sk_buff *skb;
529         int rc;
530 
531         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
532                                      NFC_DIGITAL_RF_TECH_106A);
533         if (rc)
534                 return rc;
535 
536         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
537                                      NFC_DIGITAL_FRAMING_NFCA_SHORT);
538         if (rc)
539                 return rc;
540 
541         skb = digital_skb_alloc(ddev, 1);
542         if (!skb)
543                 return -ENOMEM;
544 
545         skb_put_u8(skb, DIGITAL_CMD_SENS_REQ);
546 
547         rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sens_res, NULL);
548         if (rc)
549                 kfree_skb(skb);
550 
551         return rc;
552 }
553 
554 int digital_in_recv_mifare_res(struct sk_buff *resp)
555 {
556         /* Successful READ command response is 16 data bytes + 2 CRC bytes long.
557          * Since the driver can't differentiate a ACK/NACK response from a valid
558          * READ response, the CRC calculation must be handled at digital level
559          * even if the driver supports it for this technology.
560          */
561         if (resp->len == DIGITAL_MIFARE_READ_RES_LEN + DIGITAL_CRC_LEN) {
562                 if (digital_skb_check_crc_a(resp)) {
563                         PROTOCOL_ERR("9.4.1.2");
564                         return -EIO;
565                 }
566 
567                 return 0;
568         }
569 
570         /* ACK response (i.e. successful WRITE). */
571         if (resp->len == 1 && resp->data[0] == DIGITAL_MIFARE_ACK_RES) {
572                 resp->data[0] = 0;
573                 return 0;
574         }
575 
576         /* NACK and any other responses are treated as error. */
577         return -EIO;
578 }
579 
580 static void digital_in_recv_attrib_res(struct nfc_digital_dev *ddev, void *arg,
581                                        struct sk_buff *resp)
582 {
583         struct nfc_target *target = arg;
584         struct digital_attrib_res *attrib_res;
585         int rc;
586 
587         if (IS_ERR(resp)) {
588                 rc = PTR_ERR(resp);
589                 resp = NULL;
590                 goto exit;
591         }
592 
593         if (resp->len < sizeof(*attrib_res)) {
594                 PROTOCOL_ERR("12.6.2");
595                 rc = -EIO;
596                 goto exit;
597         }
598 
599         attrib_res = (struct digital_attrib_res *)resp->data;
600 
601         if (attrib_res->mbli_did & 0x0f) {
602                 PROTOCOL_ERR("12.6.2.1");
603                 rc = -EIO;
604                 goto exit;
605         }
606 
607         rc = digital_target_found(ddev, target, NFC_PROTO_ISO14443_B);
608 
609 exit:
610         dev_kfree_skb(resp);
611         kfree(target);
612 
613         if (rc)
614                 digital_poll_next_tech(ddev);
615 }
616 
617 static int digital_in_send_attrib_req(struct nfc_digital_dev *ddev,
618                                struct nfc_target *target,
619                                struct digital_sensb_res *sensb_res)
620 {
621         struct digital_attrib_req *attrib_req;
622         struct sk_buff *skb;
623         int rc;
624 
625         skb = digital_skb_alloc(ddev, sizeof(*attrib_req));
626         if (!skb)
627                 return -ENOMEM;
628 
629         attrib_req = skb_put(skb, sizeof(*attrib_req));
630 
631         attrib_req->cmd = DIGITAL_CMD_ATTRIB_REQ;
632         memcpy(attrib_req->nfcid0, sensb_res->nfcid0,
633                sizeof(attrib_req->nfcid0));
634         attrib_req->param1 = DIGITAL_ATTRIB_P1_TR0_DEFAULT |
635                              DIGITAL_ATTRIB_P1_TR1_DEFAULT;
636         attrib_req->param2 = DIGITAL_ATTRIB_P2_LISTEN_POLL_1 |
637                              DIGITAL_ATTRIB_P2_POLL_LISTEN_1 |
638                              DIGITAL_ATTRIB_P2_MAX_FRAME_256;
639         attrib_req->param3 = sensb_res->proto_info[1] & 0x07;
640         attrib_req->param4 = DIGITAL_ATTRIB_P4_DID(0);
641 
642         rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_attrib_res,
643                                  target);
644         if (rc)
645                 kfree_skb(skb);
646 
647         return rc;
648 }
649 
650 static void digital_in_recv_sensb_res(struct nfc_digital_dev *ddev, void *arg,
651                                       struct sk_buff *resp)
652 {
653         struct nfc_target *target = NULL;
654         struct digital_sensb_res *sensb_res;
655         u8 fsci;
656         int rc;
657 
658         if (IS_ERR(resp)) {
659                 rc = PTR_ERR(resp);
660                 resp = NULL;
661                 goto exit;
662         }
663 
664         if (resp->len != sizeof(*sensb_res)) {
665                 PROTOCOL_ERR("5.6.2.1");
666                 rc = -EIO;
667                 goto exit;
668         }
669 
670         sensb_res = (struct digital_sensb_res *)resp->data;
671 
672         if (sensb_res->cmd != DIGITAL_CMD_SENSB_RES) {
673                 PROTOCOL_ERR("5.6.2");
674                 rc = -EIO;
675                 goto exit;
676         }
677 
678         if (!(sensb_res->proto_info[1] & BIT(0))) {
679                 PROTOCOL_ERR("5.6.2.12");
680                 rc = -EIO;
681                 goto exit;
682         }
683 
684         if (sensb_res->proto_info[1] & BIT(3)) {
685                 PROTOCOL_ERR("5.6.2.16");
686                 rc = -EIO;
687                 goto exit;
688         }
689 
690         fsci = DIGITAL_SENSB_FSCI(sensb_res->proto_info[1]);
691         if (fsci >= 8)
692                 ddev->target_fsc = DIGITAL_ATS_MAX_FSC;
693         else
694                 ddev->target_fsc = digital_ats_fsc[fsci];
695 
696         target = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
697         if (!target) {
698                 rc = -ENOMEM;
699                 goto exit;
700         }
701 
702         rc = digital_in_send_attrib_req(ddev, target, sensb_res);
703 
704 exit:
705         dev_kfree_skb(resp);
706 
707         if (rc) {
708                 kfree(target);
709                 digital_poll_next_tech(ddev);
710         }
711 }
712 
713 int digital_in_send_sensb_req(struct nfc_digital_dev *ddev, u8 rf_tech)
714 {
715         struct digital_sensb_req *sensb_req;
716         struct sk_buff *skb;
717         int rc;
718 
719         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
720                                      NFC_DIGITAL_RF_TECH_106B);
721         if (rc)
722                 return rc;
723 
724         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
725                                      NFC_DIGITAL_FRAMING_NFCB);
726         if (rc)
727                 return rc;
728 
729         skb = digital_skb_alloc(ddev, sizeof(*sensb_req));
730         if (!skb)
731                 return -ENOMEM;
732 
733         sensb_req = skb_put(skb, sizeof(*sensb_req));
734 
735         sensb_req->cmd = DIGITAL_CMD_SENSB_REQ;
736         sensb_req->afi = 0x00; /* All families and sub-families */
737         sensb_req->param = DIGITAL_SENSB_N(0);
738 
739         rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sensb_res,
740                                  NULL);
741         if (rc)
742                 kfree_skb(skb);
743 
744         return rc;
745 }
746 
747 static void digital_in_recv_sensf_res(struct nfc_digital_dev *ddev, void *arg,
748                                    struct sk_buff *resp)
749 {
750         int rc;
751         u8 proto;
752         struct nfc_target target;
753         struct digital_sensf_res *sensf_res;
754 
755         if (IS_ERR(resp)) {
756                 rc = PTR_ERR(resp);
757                 resp = NULL;
758                 goto exit;
759         }
760 
761         if (resp->len < DIGITAL_SENSF_RES_MIN_LENGTH) {
762                 rc = -EIO;
763                 goto exit;
764         }
765 
766         if (!DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
767                 rc = digital_skb_check_crc_f(resp);
768                 if (rc) {
769                         PROTOCOL_ERR("6.4.1.8");
770                         goto exit;
771                 }
772         }
773 
774         skb_pull(resp, 1);
775 
776         memset(&target, 0, sizeof(struct nfc_target));
777 
778         sensf_res = (struct digital_sensf_res *)resp->data;
779 
780         memcpy(target.sensf_res, sensf_res, resp->len);
781         target.sensf_res_len = resp->len;
782 
783         memcpy(target.nfcid2, sensf_res->nfcid2, NFC_NFCID2_MAXSIZE);
784         target.nfcid2_len = NFC_NFCID2_MAXSIZE;
785 
786         if (target.nfcid2[0] == DIGITAL_SENSF_NFCID2_NFC_DEP_B1 &&
787             target.nfcid2[1] == DIGITAL_SENSF_NFCID2_NFC_DEP_B2)
788                 proto = NFC_PROTO_NFC_DEP;
789         else
790                 proto = NFC_PROTO_FELICA;
791 
792         rc = digital_target_found(ddev, &target, proto);
793 
794 exit:
795         dev_kfree_skb(resp);
796 
797         if (rc)
798                 digital_poll_next_tech(ddev);
799 }
800 
801 int digital_in_send_sensf_req(struct nfc_digital_dev *ddev, u8 rf_tech)
802 {
803         struct digital_sensf_req *sensf_req;
804         struct sk_buff *skb;
805         int rc;
806         u8 size;
807 
808         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
809         if (rc)
810                 return rc;
811 
812         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
813                                      NFC_DIGITAL_FRAMING_NFCF);
814         if (rc)
815                 return rc;
816 
817         size = sizeof(struct digital_sensf_req);
818 
819         skb = digital_skb_alloc(ddev, size);
820         if (!skb)
821                 return -ENOMEM;
822 
823         skb_put(skb, size);
824 
825         sensf_req = (struct digital_sensf_req *)skb->data;
826         sensf_req->cmd = DIGITAL_CMD_SENSF_REQ;
827         sensf_req->sc1 = 0xFF;
828         sensf_req->sc2 = 0xFF;
829         sensf_req->rc = 0;
830         sensf_req->tsn = 0;
831 
832         *(u8 *)skb_push(skb, 1) = size + 1;
833 
834         if (!DIGITAL_DRV_CAPS_IN_CRC(ddev))
835                 digital_skb_add_crc_f(skb);
836 
837         rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sensf_res,
838                                  NULL);
839         if (rc)
840                 kfree_skb(skb);
841 
842         return rc;
843 }
844 
845 static void digital_in_recv_iso15693_inv_res(struct nfc_digital_dev *ddev,
846                 void *arg, struct sk_buff *resp)
847 {
848         struct digital_iso15693_inv_res *res;
849         struct nfc_target *target = NULL;
850         int rc;
851 
852         if (IS_ERR(resp)) {
853                 rc = PTR_ERR(resp);
854                 resp = NULL;
855                 goto out_free_skb;
856         }
857 
858         if (resp->len != sizeof(*res)) {
859                 rc = -EIO;
860                 goto out_free_skb;
861         }
862 
863         res = (struct digital_iso15693_inv_res *)resp->data;
864 
865         if (!DIGITAL_ISO15693_RES_IS_VALID(res->flags)) {
866                 PROTOCOL_ERR("ISO15693 - 10.3.1");
867                 rc = -EINVAL;
868                 goto out_free_skb;
869         }
870 
871         target = kzalloc(sizeof(*target), GFP_KERNEL);
872         if (!target) {
873                 rc = -ENOMEM;
874                 goto out_free_skb;
875         }
876 
877         target->is_iso15693 = 1;
878         target->iso15693_dsfid = res->dsfid;
879         memcpy(target->iso15693_uid, &res->uid, sizeof(target->iso15693_uid));
880 
881         rc = digital_target_found(ddev, target, NFC_PROTO_ISO15693);
882 
883         kfree(target);
884 
885 out_free_skb:
886         dev_kfree_skb(resp);
887 
888         if (rc)
889                 digital_poll_next_tech(ddev);
890 }
891 
892 int digital_in_send_iso15693_inv_req(struct nfc_digital_dev *ddev, u8 rf_tech)
893 {
894         struct digital_iso15693_inv_req *req;
895         struct sk_buff *skb;
896         int rc;
897 
898         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
899                                      NFC_DIGITAL_RF_TECH_ISO15693);
900         if (rc)
901                 return rc;
902 
903         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
904                                      NFC_DIGITAL_FRAMING_ISO15693_INVENTORY);
905         if (rc)
906                 return rc;
907 
908         skb = digital_skb_alloc(ddev, sizeof(*req));
909         if (!skb)
910                 return -ENOMEM;
911 
912         skb_put(skb, sizeof(*req) - sizeof(req->mask)); /* No mask */
913         req = (struct digital_iso15693_inv_req *)skb->data;
914 
915         /* Single sub-carrier, high data rate, no AFI, single slot
916          * Inventory command
917          */
918         req->flags = DIGITAL_ISO15693_REQ_FLAG_DATA_RATE |
919                      DIGITAL_ISO15693_REQ_FLAG_INVENTORY |
920                      DIGITAL_ISO15693_REQ_FLAG_NB_SLOTS;
921         req->cmd = DIGITAL_CMD_ISO15693_INVENTORY_REQ;
922         req->mask_len = 0;
923 
924         rc = digital_in_send_cmd(ddev, skb, 30,
925                                  digital_in_recv_iso15693_inv_res, NULL);
926         if (rc)
927                 kfree_skb(skb);
928 
929         return rc;
930 }
931 
932 static int digital_tg_send_sel_res(struct nfc_digital_dev *ddev)
933 {
934         struct sk_buff *skb;
935         int rc;
936 
937         skb = digital_skb_alloc(ddev, 1);
938         if (!skb)
939                 return -ENOMEM;
940 
941         skb_put_u8(skb, DIGITAL_SEL_RES_NFC_DEP);
942 
943         if (!DIGITAL_DRV_CAPS_TG_CRC(ddev))
944                 digital_skb_add_crc_a(skb);
945 
946         rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
947                                      NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE);
948         if (rc) {
949                 kfree_skb(skb);
950                 return rc;
951         }
952 
953         rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_atr_req,
954                                  NULL);
955         if (rc)
956                 kfree_skb(skb);
957 
958         return rc;
959 }
960 
961 static void digital_tg_recv_sel_req(struct nfc_digital_dev *ddev, void *arg,
962                                     struct sk_buff *resp)
963 {
964         int rc;
965 
966         if (IS_ERR(resp)) {
967                 rc = PTR_ERR(resp);
968                 resp = NULL;
969                 goto exit;
970         }
971 
972         if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
973                 rc = digital_skb_check_crc_a(resp);
974                 if (rc) {
975                         PROTOCOL_ERR("4.4.1.3");
976                         goto exit;
977                 }
978         }
979 
980         /* Silently ignore SEL_REQ content and send a SEL_RES for NFC-DEP */
981 
982         rc = digital_tg_send_sel_res(ddev);
983 
984 exit:
985         if (rc)
986                 digital_poll_next_tech(ddev);
987 
988         dev_kfree_skb(resp);
989 }
990 
991 static int digital_tg_send_sdd_res(struct nfc_digital_dev *ddev)
992 {
993         struct sk_buff *skb;
994         struct digital_sdd_res *sdd_res;
995         int rc, i;
996 
997         skb = digital_skb_alloc(ddev, sizeof(struct digital_sdd_res));
998         if (!skb)
999                 return -ENOMEM;
1000 
1001         skb_put(skb, sizeof(struct digital_sdd_res));
1002         sdd_res = (struct digital_sdd_res *)skb->data;
1003 
1004         sdd_res->nfcid1[0] = 0x08;
1005         get_random_bytes(sdd_res->nfcid1 + 1, 3);
1006 
1007         sdd_res->bcc = 0;
1008         for (i = 0; i < 4; i++)
1009                 sdd_res->bcc ^= sdd_res->nfcid1[i];
1010 
1011         rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1012                                 NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A);
1013         if (rc) {
1014                 kfree_skb(skb);
1015                 return rc;
1016         }
1017 
1018         rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sel_req,
1019                                  NULL);
1020         if (rc)
1021                 kfree_skb(skb);
1022 
1023         return rc;
1024 }
1025 
1026 static void digital_tg_recv_sdd_req(struct nfc_digital_dev *ddev, void *arg,
1027                                     struct sk_buff *resp)
1028 {
1029         u8 *sdd_req;
1030         int rc;
1031 
1032         if (IS_ERR(resp)) {
1033                 rc = PTR_ERR(resp);
1034                 resp = NULL;
1035                 goto exit;
1036         }
1037 
1038         sdd_req = resp->data;
1039 
1040         if (resp->len < 2 || sdd_req[0] != DIGITAL_CMD_SEL_REQ_CL1 ||
1041             sdd_req[1] != DIGITAL_SDD_REQ_SEL_PAR) {
1042                 rc = -EINVAL;
1043                 goto exit;
1044         }
1045 
1046         rc = digital_tg_send_sdd_res(ddev);
1047 
1048 exit:
1049         if (rc)
1050                 digital_poll_next_tech(ddev);
1051 
1052         dev_kfree_skb(resp);
1053 }
1054 
1055 static int digital_tg_send_sens_res(struct nfc_digital_dev *ddev)
1056 {
1057         struct sk_buff *skb;
1058         u8 *sens_res;
1059         int rc;
1060 
1061         skb = digital_skb_alloc(ddev, 2);
1062         if (!skb)
1063                 return -ENOMEM;
1064 
1065         sens_res = skb_put(skb, 2);
1066 
1067         sens_res[0] = (DIGITAL_SENS_RES_NFC_DEP >> 8) & 0xFF;
1068         sens_res[1] = DIGITAL_SENS_RES_NFC_DEP & 0xFF;
1069 
1070         rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1071                                      NFC_DIGITAL_FRAMING_NFCA_STANDARD);
1072         if (rc) {
1073                 kfree_skb(skb);
1074                 return rc;
1075         }
1076 
1077         rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sdd_req,
1078                                  NULL);
1079         if (rc)
1080                 kfree_skb(skb);
1081 
1082         return rc;
1083 }
1084 
1085 void digital_tg_recv_sens_req(struct nfc_digital_dev *ddev, void *arg,
1086                               struct sk_buff *resp)
1087 {
1088         u8 sens_req;
1089         int rc;
1090 
1091         if (IS_ERR(resp)) {
1092                 rc = PTR_ERR(resp);
1093                 resp = NULL;
1094                 goto exit;
1095         }
1096 
1097         sens_req = resp->data[0];
1098 
1099         if (!resp->len || (sens_req != DIGITAL_CMD_SENS_REQ &&
1100             sens_req != DIGITAL_CMD_ALL_REQ)) {
1101                 rc = -EINVAL;
1102                 goto exit;
1103         }
1104 
1105         rc = digital_tg_send_sens_res(ddev);
1106 
1107 exit:
1108         if (rc)
1109                 digital_poll_next_tech(ddev);
1110 
1111         dev_kfree_skb(resp);
1112 }
1113 
1114 static void digital_tg_recv_atr_or_sensf_req(struct nfc_digital_dev *ddev,
1115                 void *arg, struct sk_buff *resp)
1116 {
1117         if (!IS_ERR(resp) && (resp->len >= 2) &&
1118                         (resp->data[1] == DIGITAL_CMD_SENSF_REQ))
1119                 digital_tg_recv_sensf_req(ddev, arg, resp);
1120         else
1121                 digital_tg_recv_atr_req(ddev, arg, resp);
1122 
1123         return;
1124 }
1125 
1126 static int digital_tg_send_sensf_res(struct nfc_digital_dev *ddev,
1127                               struct digital_sensf_req *sensf_req)
1128 {
1129         struct sk_buff *skb;
1130         u8 size;
1131         int rc;
1132         struct digital_sensf_res *sensf_res;
1133 
1134         size = sizeof(struct digital_sensf_res);
1135 
1136         if (sensf_req->rc == DIGITAL_SENSF_REQ_RC_NONE)
1137                 size -= sizeof(sensf_res->rd);
1138 
1139         skb = digital_skb_alloc(ddev, size);
1140         if (!skb)
1141                 return -ENOMEM;
1142 
1143         skb_put(skb, size);
1144 
1145         sensf_res = (struct digital_sensf_res *)skb->data;
1146 
1147         memset(sensf_res, 0, size);
1148 
1149         sensf_res->cmd = DIGITAL_CMD_SENSF_RES;
1150         sensf_res->nfcid2[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1;
1151         sensf_res->nfcid2[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2;
1152         get_random_bytes(&sensf_res->nfcid2[2], 6);
1153 
1154         switch (sensf_req->rc) {
1155         case DIGITAL_SENSF_REQ_RC_SC:
1156                 sensf_res->rd[0] = sensf_req->sc1;
1157                 sensf_res->rd[1] = sensf_req->sc2;
1158                 break;
1159         case DIGITAL_SENSF_REQ_RC_AP:
1160                 sensf_res->rd[0] = DIGITAL_SENSF_RES_RD_AP_B1;
1161                 sensf_res->rd[1] = DIGITAL_SENSF_RES_RD_AP_B2;
1162                 break;
1163         }
1164 
1165         *(u8 *)skb_push(skb, sizeof(u8)) = size + 1;
1166 
1167         if (!DIGITAL_DRV_CAPS_TG_CRC(ddev))
1168                 digital_skb_add_crc_f(skb);
1169 
1170         rc = digital_tg_send_cmd(ddev, skb, 300,
1171                                  digital_tg_recv_atr_or_sensf_req, NULL);
1172         if (rc)
1173                 kfree_skb(skb);
1174 
1175         return rc;
1176 }
1177 
1178 void digital_tg_recv_sensf_req(struct nfc_digital_dev *ddev, void *arg,
1179                                struct sk_buff *resp)
1180 {
1181         struct digital_sensf_req *sensf_req;
1182         int rc;
1183 
1184         if (IS_ERR(resp)) {
1185                 rc = PTR_ERR(resp);
1186                 resp = NULL;
1187                 goto exit;
1188         }
1189 
1190         if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
1191                 rc = digital_skb_check_crc_f(resp);
1192                 if (rc) {
1193                         PROTOCOL_ERR("6.4.1.8");
1194                         goto exit;
1195                 }
1196         }
1197 
1198         if (resp->len != sizeof(struct digital_sensf_req) + 1) {
1199                 rc = -EINVAL;
1200                 goto exit;
1201         }
1202 
1203         skb_pull(resp, 1);
1204         sensf_req = (struct digital_sensf_req *)resp->data;
1205 
1206         if (sensf_req->cmd != DIGITAL_CMD_SENSF_REQ) {
1207                 rc = -EINVAL;
1208                 goto exit;
1209         }
1210 
1211         rc = digital_tg_send_sensf_res(ddev, sensf_req);
1212 
1213 exit:
1214         if (rc)
1215                 digital_poll_next_tech(ddev);
1216 
1217         dev_kfree_skb(resp);
1218 }
1219 
1220 static int digital_tg_config_nfca(struct nfc_digital_dev *ddev)
1221 {
1222         int rc;
1223 
1224         rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
1225                                      NFC_DIGITAL_RF_TECH_106A);
1226         if (rc)
1227                 return rc;
1228 
1229         return digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1230                                        NFC_DIGITAL_FRAMING_NFCA_NFC_DEP);
1231 }
1232 
1233 int digital_tg_listen_nfca(struct nfc_digital_dev *ddev, u8 rf_tech)
1234 {
1235         int rc;
1236 
1237         rc = digital_tg_config_nfca(ddev);
1238         if (rc)
1239                 return rc;
1240 
1241         return digital_tg_listen(ddev, 300, digital_tg_recv_sens_req, NULL);
1242 }
1243 
1244 static int digital_tg_config_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech)
1245 {
1246         int rc;
1247 
1248         rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
1249         if (rc)
1250                 return rc;
1251 
1252         return digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1253                                        NFC_DIGITAL_FRAMING_NFCF_NFC_DEP);
1254 }
1255 
1256 int digital_tg_listen_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech)
1257 {
1258         int rc;
1259 
1260         rc = digital_tg_config_nfcf(ddev, rf_tech);
1261         if (rc)
1262                 return rc;
1263 
1264         return digital_tg_listen(ddev, 300, digital_tg_recv_sensf_req, NULL);
1265 }
1266 
1267 void digital_tg_recv_md_req(struct nfc_digital_dev *ddev, void *arg,
1268                             struct sk_buff *resp)
1269 {
1270         u8 rf_tech;
1271         int rc;
1272 
1273         if (IS_ERR(resp)) {
1274                 resp = NULL;
1275                 goto exit_free_skb;
1276         }
1277 
1278         rc = ddev->ops->tg_get_rf_tech(ddev, &rf_tech);
1279         if (rc)
1280                 goto exit_free_skb;
1281 
1282         switch (rf_tech) {
1283         case NFC_DIGITAL_RF_TECH_106A:
1284                 rc = digital_tg_config_nfca(ddev);
1285                 if (rc)
1286                         goto exit_free_skb;
1287                 digital_tg_recv_sens_req(ddev, arg, resp);
1288                 break;
1289         case NFC_DIGITAL_RF_TECH_212F:
1290         case NFC_DIGITAL_RF_TECH_424F:
1291                 rc = digital_tg_config_nfcf(ddev, rf_tech);
1292                 if (rc)
1293                         goto exit_free_skb;
1294                 digital_tg_recv_sensf_req(ddev, arg, resp);
1295                 break;
1296         default:
1297                 goto exit_free_skb;
1298         }
1299 
1300         return;
1301 
1302 exit_free_skb:
1303         digital_poll_next_tech(ddev);
1304         dev_kfree_skb(resp);
1305 }
1306 

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