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

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

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.12 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.55 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.136 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.191 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ 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.85 ] ~ [ 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-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 <linux/module.h>
 19 
 20 #include "digital.h"
 21 
 22 #define DIGITAL_PROTO_NFCA_RF_TECH \
 23         (NFC_PROTO_JEWEL_MASK | NFC_PROTO_MIFARE_MASK | NFC_PROTO_NFC_DEP_MASK)
 24 
 25 #define DIGITAL_PROTO_NFCF_RF_TECH \
 26         (NFC_PROTO_FELICA_MASK | NFC_PROTO_NFC_DEP_MASK)
 27 
 28 #define DIGITAL_PROTO_ISO15693_RF_TECH  NFC_PROTO_ISO15693_MASK
 29 
 30 struct digital_cmd {
 31         struct list_head queue;
 32 
 33         u8 type;
 34         u8 pending;
 35 
 36         u16 timeout;
 37         struct sk_buff *req;
 38         struct sk_buff *resp;
 39         struct digital_tg_mdaa_params *mdaa_params;
 40 
 41         nfc_digital_cmd_complete_t cmd_cb;
 42         void *cb_context;
 43 };
 44 
 45 struct sk_buff *digital_skb_alloc(struct nfc_digital_dev *ddev,
 46                                   unsigned int len)
 47 {
 48         struct sk_buff *skb;
 49 
 50         skb = alloc_skb(len + ddev->tx_headroom + ddev->tx_tailroom,
 51                         GFP_KERNEL);
 52         if (skb)
 53                 skb_reserve(skb, ddev->tx_headroom);
 54 
 55         return skb;
 56 }
 57 
 58 void digital_skb_add_crc(struct sk_buff *skb, crc_func_t crc_func, u16 init,
 59                          u8 bitwise_inv, u8 msb_first)
 60 {
 61         u16 crc;
 62 
 63         crc = crc_func(init, skb->data, skb->len);
 64 
 65         if (bitwise_inv)
 66                 crc = ~crc;
 67 
 68         if (msb_first)
 69                 crc = __fswab16(crc);
 70 
 71         *skb_put(skb, 1) = crc & 0xFF;
 72         *skb_put(skb, 1) = (crc >> 8) & 0xFF;
 73 }
 74 
 75 int digital_skb_check_crc(struct sk_buff *skb, crc_func_t crc_func,
 76                           u16 crc_init, u8 bitwise_inv, u8 msb_first)
 77 {
 78         int rc;
 79         u16 crc;
 80 
 81         if (skb->len <= 2)
 82                 return -EIO;
 83 
 84         crc = crc_func(crc_init, skb->data, skb->len - 2);
 85 
 86         if (bitwise_inv)
 87                 crc = ~crc;
 88 
 89         if (msb_first)
 90                 crc = __swab16(crc);
 91 
 92         rc = (skb->data[skb->len - 2] - (crc & 0xFF)) +
 93              (skb->data[skb->len - 1] - ((crc >> 8) & 0xFF));
 94 
 95         if (rc)
 96                 return -EIO;
 97 
 98         skb_trim(skb, skb->len - 2);
 99 
100         return 0;
101 }
102 
103 static inline void digital_switch_rf(struct nfc_digital_dev *ddev, bool on)
104 {
105         ddev->ops->switch_rf(ddev, on);
106 }
107 
108 static inline void digital_abort_cmd(struct nfc_digital_dev *ddev)
109 {
110         ddev->ops->abort_cmd(ddev);
111 }
112 
113 static void digital_wq_cmd_complete(struct work_struct *work)
114 {
115         struct digital_cmd *cmd;
116         struct nfc_digital_dev *ddev = container_of(work,
117                                                     struct nfc_digital_dev,
118                                                     cmd_complete_work);
119 
120         mutex_lock(&ddev->cmd_lock);
121 
122         cmd = list_first_entry_or_null(&ddev->cmd_queue, struct digital_cmd,
123                                        queue);
124         if (!cmd) {
125                 mutex_unlock(&ddev->cmd_lock);
126                 return;
127         }
128 
129         list_del(&cmd->queue);
130 
131         mutex_unlock(&ddev->cmd_lock);
132 
133         if (!IS_ERR(cmd->resp))
134                 print_hex_dump_debug("DIGITAL RX: ", DUMP_PREFIX_NONE, 16, 1,
135                                      cmd->resp->data, cmd->resp->len, false);
136 
137         cmd->cmd_cb(ddev, cmd->cb_context, cmd->resp);
138 
139         kfree(cmd->mdaa_params);
140         kfree(cmd);
141 
142         schedule_work(&ddev->cmd_work);
143 }
144 
145 static void digital_send_cmd_complete(struct nfc_digital_dev *ddev,
146                                       void *arg, struct sk_buff *resp)
147 {
148         struct digital_cmd *cmd = arg;
149 
150         cmd->resp = resp;
151 
152         schedule_work(&ddev->cmd_complete_work);
153 }
154 
155 static void digital_wq_cmd(struct work_struct *work)
156 {
157         int rc;
158         struct digital_cmd *cmd;
159         struct digital_tg_mdaa_params *params;
160         struct nfc_digital_dev *ddev = container_of(work,
161                                                     struct nfc_digital_dev,
162                                                     cmd_work);
163 
164         mutex_lock(&ddev->cmd_lock);
165 
166         cmd = list_first_entry_or_null(&ddev->cmd_queue, struct digital_cmd,
167                                        queue);
168         if (!cmd || cmd->pending) {
169                 mutex_unlock(&ddev->cmd_lock);
170                 return;
171         }
172 
173         mutex_unlock(&ddev->cmd_lock);
174 
175         if (cmd->req)
176                 print_hex_dump_debug("DIGITAL TX: ", DUMP_PREFIX_NONE, 16, 1,
177                                      cmd->req->data, cmd->req->len, false);
178 
179         switch (cmd->type) {
180         case DIGITAL_CMD_IN_SEND:
181                 rc = ddev->ops->in_send_cmd(ddev, cmd->req, cmd->timeout,
182                                             digital_send_cmd_complete, cmd);
183                 break;
184 
185         case DIGITAL_CMD_TG_SEND:
186                 rc = ddev->ops->tg_send_cmd(ddev, cmd->req, cmd->timeout,
187                                             digital_send_cmd_complete, cmd);
188                 break;
189 
190         case DIGITAL_CMD_TG_LISTEN:
191                 rc = ddev->ops->tg_listen(ddev, cmd->timeout,
192                                           digital_send_cmd_complete, cmd);
193                 break;
194 
195         case DIGITAL_CMD_TG_LISTEN_MDAA:
196                 params = cmd->mdaa_params;
197 
198                 rc = ddev->ops->tg_listen_mdaa(ddev, params, cmd->timeout,
199                                                digital_send_cmd_complete, cmd);
200                 break;
201 
202         default:
203                 pr_err("Unknown cmd type %d\n", cmd->type);
204                 return;
205         }
206 
207         if (!rc)
208                 return;
209 
210         pr_err("in_send_command returned err %d\n", rc);
211 
212         mutex_lock(&ddev->cmd_lock);
213         list_del(&cmd->queue);
214         mutex_unlock(&ddev->cmd_lock);
215 
216         kfree_skb(cmd->req);
217         kfree(cmd->mdaa_params);
218         kfree(cmd);
219 
220         schedule_work(&ddev->cmd_work);
221 }
222 
223 int digital_send_cmd(struct nfc_digital_dev *ddev, u8 cmd_type,
224                      struct sk_buff *skb, struct digital_tg_mdaa_params *params,
225                      u16 timeout, nfc_digital_cmd_complete_t cmd_cb,
226                      void *cb_context)
227 {
228         struct digital_cmd *cmd;
229 
230         cmd = kzalloc(sizeof(struct digital_cmd), GFP_KERNEL);
231         if (!cmd)
232                 return -ENOMEM;
233 
234         cmd->type = cmd_type;
235         cmd->timeout = timeout;
236         cmd->req = skb;
237         cmd->mdaa_params = params;
238         cmd->cmd_cb = cmd_cb;
239         cmd->cb_context = cb_context;
240         INIT_LIST_HEAD(&cmd->queue);
241 
242         mutex_lock(&ddev->cmd_lock);
243         list_add_tail(&cmd->queue, &ddev->cmd_queue);
244         mutex_unlock(&ddev->cmd_lock);
245 
246         schedule_work(&ddev->cmd_work);
247 
248         return 0;
249 }
250 
251 int digital_in_configure_hw(struct nfc_digital_dev *ddev, int type, int param)
252 {
253         int rc;
254 
255         rc = ddev->ops->in_configure_hw(ddev, type, param);
256         if (rc)
257                 pr_err("in_configure_hw failed: %d\n", rc);
258 
259         return rc;
260 }
261 
262 int digital_tg_configure_hw(struct nfc_digital_dev *ddev, int type, int param)
263 {
264         int rc;
265 
266         rc = ddev->ops->tg_configure_hw(ddev, type, param);
267         if (rc)
268                 pr_err("tg_configure_hw failed: %d\n", rc);
269 
270         return rc;
271 }
272 
273 static int digital_tg_listen_mdaa(struct nfc_digital_dev *ddev, u8 rf_tech)
274 {
275         struct digital_tg_mdaa_params *params;
276 
277         params = kzalloc(sizeof(struct digital_tg_mdaa_params), GFP_KERNEL);
278         if (!params)
279                 return -ENOMEM;
280 
281         params->sens_res = DIGITAL_SENS_RES_NFC_DEP;
282         get_random_bytes(params->nfcid1, sizeof(params->nfcid1));
283         params->sel_res = DIGITAL_SEL_RES_NFC_DEP;
284 
285         params->nfcid2[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1;
286         params->nfcid2[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2;
287         get_random_bytes(params->nfcid2 + 2, NFC_NFCID2_MAXSIZE - 2);
288         params->sc = DIGITAL_SENSF_FELICA_SC;
289 
290         return digital_send_cmd(ddev, DIGITAL_CMD_TG_LISTEN_MDAA, NULL, params,
291                                 500, digital_tg_recv_atr_req, NULL);
292 }
293 
294 int digital_target_found(struct nfc_digital_dev *ddev,
295                          struct nfc_target *target, u8 protocol)
296 {
297         int rc;
298         u8 framing;
299         u8 rf_tech;
300         int (*check_crc)(struct sk_buff *skb);
301         void (*add_crc)(struct sk_buff *skb);
302 
303         rf_tech = ddev->poll_techs[ddev->poll_tech_index].rf_tech;
304 
305         switch (protocol) {
306         case NFC_PROTO_JEWEL:
307                 framing = NFC_DIGITAL_FRAMING_NFCA_T1T;
308                 check_crc = digital_skb_check_crc_b;
309                 add_crc = digital_skb_add_crc_b;
310                 break;
311 
312         case NFC_PROTO_MIFARE:
313                 framing = NFC_DIGITAL_FRAMING_NFCA_T2T;
314                 check_crc = digital_skb_check_crc_a;
315                 add_crc = digital_skb_add_crc_a;
316                 break;
317 
318         case NFC_PROTO_FELICA:
319                 framing = NFC_DIGITAL_FRAMING_NFCF_T3T;
320                 check_crc = digital_skb_check_crc_f;
321                 add_crc = digital_skb_add_crc_f;
322                 break;
323 
324         case NFC_PROTO_NFC_DEP:
325                 if (rf_tech == NFC_DIGITAL_RF_TECH_106A) {
326                         framing = NFC_DIGITAL_FRAMING_NFCA_NFC_DEP;
327                         check_crc = digital_skb_check_crc_a;
328                         add_crc = digital_skb_add_crc_a;
329                 } else {
330                         framing = NFC_DIGITAL_FRAMING_NFCF_NFC_DEP;
331                         check_crc = digital_skb_check_crc_f;
332                         add_crc = digital_skb_add_crc_f;
333                 }
334                 break;
335 
336         case NFC_PROTO_ISO15693:
337                 framing = NFC_DIGITAL_FRAMING_ISO15693_T5T;
338                 check_crc = digital_skb_check_crc_b;
339                 add_crc = digital_skb_add_crc_b;
340                 break;
341 
342         case NFC_PROTO_ISO14443:
343                 framing = NFC_DIGITAL_FRAMING_NFCA_T4T;
344                 check_crc = digital_skb_check_crc_a;
345                 add_crc = digital_skb_add_crc_a;
346                 break;
347 
348         default:
349                 pr_err("Invalid protocol %d\n", protocol);
350                 return -EINVAL;
351         }
352 
353         pr_debug("rf_tech=%d, protocol=%d\n", rf_tech, protocol);
354 
355         ddev->curr_rf_tech = rf_tech;
356 
357         if (DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
358                 ddev->skb_add_crc = digital_skb_add_crc_none;
359                 ddev->skb_check_crc = digital_skb_check_crc_none;
360         } else {
361                 ddev->skb_add_crc = add_crc;
362                 ddev->skb_check_crc = check_crc;
363         }
364 
365         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, framing);
366         if (rc)
367                 return rc;
368 
369         target->supported_protocols = (1 << protocol);
370         rc = nfc_targets_found(ddev->nfc_dev, target, 1);
371         if (rc)
372                 return rc;
373 
374         ddev->poll_tech_count = 0;
375 
376         return 0;
377 }
378 
379 void digital_poll_next_tech(struct nfc_digital_dev *ddev)
380 {
381         digital_switch_rf(ddev, 0);
382 
383         mutex_lock(&ddev->poll_lock);
384 
385         if (!ddev->poll_tech_count) {
386                 mutex_unlock(&ddev->poll_lock);
387                 return;
388         }
389 
390         ddev->poll_tech_index = (ddev->poll_tech_index + 1) %
391                                 ddev->poll_tech_count;
392 
393         mutex_unlock(&ddev->poll_lock);
394 
395         schedule_work(&ddev->poll_work);
396 }
397 
398 static void digital_wq_poll(struct work_struct *work)
399 {
400         int rc;
401         struct digital_poll_tech *poll_tech;
402         struct nfc_digital_dev *ddev = container_of(work,
403                                                     struct nfc_digital_dev,
404                                                     poll_work);
405         mutex_lock(&ddev->poll_lock);
406 
407         if (!ddev->poll_tech_count) {
408                 mutex_unlock(&ddev->poll_lock);
409                 return;
410         }
411 
412         poll_tech = &ddev->poll_techs[ddev->poll_tech_index];
413 
414         mutex_unlock(&ddev->poll_lock);
415 
416         rc = poll_tech->poll_func(ddev, poll_tech->rf_tech);
417         if (rc)
418                 digital_poll_next_tech(ddev);
419 }
420 
421 static void digital_add_poll_tech(struct nfc_digital_dev *ddev, u8 rf_tech,
422                                   digital_poll_t poll_func)
423 {
424         struct digital_poll_tech *poll_tech;
425 
426         if (ddev->poll_tech_count >= NFC_DIGITAL_POLL_MODE_COUNT_MAX)
427                 return;
428 
429         poll_tech = &ddev->poll_techs[ddev->poll_tech_count++];
430 
431         poll_tech->rf_tech = rf_tech;
432         poll_tech->poll_func = poll_func;
433 }
434 
435 /**
436  * start_poll operation
437  *
438  * For every supported protocol, the corresponding polling function is added
439  * to the table of polling technologies (ddev->poll_techs[]) using
440  * digital_add_poll_tech().
441  * When a polling function fails (by timeout or protocol error) the next one is
442  * schedule by digital_poll_next_tech() on the poll workqueue (ddev->poll_work).
443  */
444 static int digital_start_poll(struct nfc_dev *nfc_dev, __u32 im_protocols,
445                               __u32 tm_protocols)
446 {
447         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
448         u32 matching_im_protocols, matching_tm_protocols;
449 
450         pr_debug("protocols: im 0x%x, tm 0x%x, supported 0x%x\n", im_protocols,
451                  tm_protocols, ddev->protocols);
452 
453         matching_im_protocols = ddev->protocols & im_protocols;
454         matching_tm_protocols = ddev->protocols & tm_protocols;
455 
456         if (!matching_im_protocols && !matching_tm_protocols) {
457                 pr_err("Unknown protocol\n");
458                 return -EINVAL;
459         }
460 
461         if (ddev->poll_tech_count) {
462                 pr_err("Already polling\n");
463                 return -EBUSY;
464         }
465 
466         if (ddev->curr_protocol) {
467                 pr_err("A target is already active\n");
468                 return -EBUSY;
469         }
470 
471         ddev->poll_tech_count = 0;
472         ddev->poll_tech_index = 0;
473 
474         if (matching_im_protocols & DIGITAL_PROTO_NFCA_RF_TECH)
475                 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_106A,
476                                       digital_in_send_sens_req);
477 
478         if (matching_im_protocols & DIGITAL_PROTO_NFCF_RF_TECH) {
479                 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_212F,
480                                       digital_in_send_sensf_req);
481 
482                 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_424F,
483                                       digital_in_send_sensf_req);
484         }
485 
486         if (matching_im_protocols & DIGITAL_PROTO_ISO15693_RF_TECH)
487                 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_ISO15693,
488                                       digital_in_send_iso15693_inv_req);
489 
490         if (matching_tm_protocols & NFC_PROTO_NFC_DEP_MASK) {
491                 if (ddev->ops->tg_listen_mdaa) {
492                         digital_add_poll_tech(ddev, 0,
493                                               digital_tg_listen_mdaa);
494                 } else {
495                         digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_106A,
496                                               digital_tg_listen_nfca);
497 
498                         digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_212F,
499                                               digital_tg_listen_nfcf);
500 
501                         digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_424F,
502                                               digital_tg_listen_nfcf);
503                 }
504         }
505 
506         if (!ddev->poll_tech_count) {
507                 pr_err("Unsupported protocols: im=0x%x, tm=0x%x\n",
508                        matching_im_protocols, matching_tm_protocols);
509                 return -EINVAL;
510         }
511 
512         schedule_work(&ddev->poll_work);
513 
514         return 0;
515 }
516 
517 static void digital_stop_poll(struct nfc_dev *nfc_dev)
518 {
519         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
520 
521         mutex_lock(&ddev->poll_lock);
522 
523         if (!ddev->poll_tech_count) {
524                 pr_err("Polling operation was not running\n");
525                 mutex_unlock(&ddev->poll_lock);
526                 return;
527         }
528 
529         ddev->poll_tech_count = 0;
530 
531         mutex_unlock(&ddev->poll_lock);
532 
533         cancel_work_sync(&ddev->poll_work);
534 
535         digital_abort_cmd(ddev);
536 }
537 
538 static int digital_dev_up(struct nfc_dev *nfc_dev)
539 {
540         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
541 
542         digital_switch_rf(ddev, 1);
543 
544         return 0;
545 }
546 
547 static int digital_dev_down(struct nfc_dev *nfc_dev)
548 {
549         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
550 
551         digital_switch_rf(ddev, 0);
552 
553         return 0;
554 }
555 
556 static int digital_dep_link_up(struct nfc_dev *nfc_dev,
557                                struct nfc_target *target,
558                                __u8 comm_mode, __u8 *gb, size_t gb_len)
559 {
560         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
561         int rc;
562 
563         rc = digital_in_send_atr_req(ddev, target, comm_mode, gb, gb_len);
564 
565         if (!rc)
566                 ddev->curr_protocol = NFC_PROTO_NFC_DEP;
567 
568         return rc;
569 }
570 
571 static int digital_dep_link_down(struct nfc_dev *nfc_dev)
572 {
573         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
574 
575         ddev->curr_protocol = 0;
576 
577         return 0;
578 }
579 
580 static int digital_activate_target(struct nfc_dev *nfc_dev,
581                                    struct nfc_target *target, __u32 protocol)
582 {
583         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
584 
585         if (ddev->poll_tech_count) {
586                 pr_err("Can't activate a target while polling\n");
587                 return -EBUSY;
588         }
589 
590         if (ddev->curr_protocol) {
591                 pr_err("A target is already active\n");
592                 return -EBUSY;
593         }
594 
595         ddev->curr_protocol = protocol;
596 
597         return 0;
598 }
599 
600 static void digital_deactivate_target(struct nfc_dev *nfc_dev,
601                                       struct nfc_target *target)
602 {
603         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
604 
605         if (!ddev->curr_protocol) {
606                 pr_err("No active target\n");
607                 return;
608         }
609 
610         ddev->curr_protocol = 0;
611 }
612 
613 static int digital_tg_send(struct nfc_dev *dev, struct sk_buff *skb)
614 {
615         struct nfc_digital_dev *ddev = nfc_get_drvdata(dev);
616 
617         return digital_tg_send_dep_res(ddev, skb);
618 }
619 
620 static void digital_in_send_complete(struct nfc_digital_dev *ddev, void *arg,
621                                      struct sk_buff *resp)
622 {
623         struct digital_data_exch *data_exch = arg;
624         int rc;
625 
626         if (IS_ERR(resp)) {
627                 rc = PTR_ERR(resp);
628                 resp = NULL;
629                 goto done;
630         }
631 
632         if (ddev->curr_protocol == NFC_PROTO_MIFARE) {
633                 rc = digital_in_recv_mifare_res(resp);
634                 /* crc check is done in digital_in_recv_mifare_res() */
635                 goto done;
636         }
637 
638         if (ddev->curr_protocol == NFC_PROTO_ISO14443) {
639                 rc = digital_in_iso_dep_pull_sod(ddev, resp);
640                 if (rc)
641                         goto done;
642         }
643 
644         rc = ddev->skb_check_crc(resp);
645 
646 done:
647         if (rc) {
648                 kfree_skb(resp);
649                 resp = NULL;
650         }
651 
652         data_exch->cb(data_exch->cb_context, resp, rc);
653 
654         kfree(data_exch);
655 }
656 
657 static int digital_in_send(struct nfc_dev *nfc_dev, struct nfc_target *target,
658                            struct sk_buff *skb, data_exchange_cb_t cb,
659                            void *cb_context)
660 {
661         struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
662         struct digital_data_exch *data_exch;
663         int rc;
664 
665         data_exch = kzalloc(sizeof(struct digital_data_exch), GFP_KERNEL);
666         if (!data_exch) {
667                 pr_err("Failed to allocate data_exch struct\n");
668                 return -ENOMEM;
669         }
670 
671         data_exch->cb = cb;
672         data_exch->cb_context = cb_context;
673 
674         if (ddev->curr_protocol == NFC_PROTO_NFC_DEP) {
675                 rc = digital_in_send_dep_req(ddev, target, skb, data_exch);
676                 goto exit;
677         }
678 
679         if (ddev->curr_protocol == NFC_PROTO_ISO14443) {
680                 rc = digital_in_iso_dep_push_sod(ddev, skb);
681                 if (rc)
682                         goto exit;
683         }
684 
685         ddev->skb_add_crc(skb);
686 
687         rc = digital_in_send_cmd(ddev, skb, 500, digital_in_send_complete,
688                                  data_exch);
689 
690 exit:
691         if (rc)
692                 kfree(data_exch);
693 
694         return rc;
695 }
696 
697 static struct nfc_ops digital_nfc_ops = {
698         .dev_up = digital_dev_up,
699         .dev_down = digital_dev_down,
700         .start_poll = digital_start_poll,
701         .stop_poll = digital_stop_poll,
702         .dep_link_up = digital_dep_link_up,
703         .dep_link_down = digital_dep_link_down,
704         .activate_target = digital_activate_target,
705         .deactivate_target = digital_deactivate_target,
706         .tm_send = digital_tg_send,
707         .im_transceive = digital_in_send,
708 };
709 
710 struct nfc_digital_dev *nfc_digital_allocate_device(struct nfc_digital_ops *ops,
711                                             __u32 supported_protocols,
712                                             __u32 driver_capabilities,
713                                             int tx_headroom, int tx_tailroom)
714 {
715         struct nfc_digital_dev *ddev;
716 
717         if (!ops->in_configure_hw || !ops->in_send_cmd || !ops->tg_listen ||
718             !ops->tg_configure_hw || !ops->tg_send_cmd || !ops->abort_cmd ||
719             !ops->switch_rf)
720                 return NULL;
721 
722         ddev = kzalloc(sizeof(struct nfc_digital_dev), GFP_KERNEL);
723         if (!ddev)
724                 return NULL;
725 
726         ddev->driver_capabilities = driver_capabilities;
727         ddev->ops = ops;
728 
729         mutex_init(&ddev->cmd_lock);
730         INIT_LIST_HEAD(&ddev->cmd_queue);
731 
732         INIT_WORK(&ddev->cmd_work, digital_wq_cmd);
733         INIT_WORK(&ddev->cmd_complete_work, digital_wq_cmd_complete);
734 
735         mutex_init(&ddev->poll_lock);
736         INIT_WORK(&ddev->poll_work, digital_wq_poll);
737 
738         if (supported_protocols & NFC_PROTO_JEWEL_MASK)
739                 ddev->protocols |= NFC_PROTO_JEWEL_MASK;
740         if (supported_protocols & NFC_PROTO_MIFARE_MASK)
741                 ddev->protocols |= NFC_PROTO_MIFARE_MASK;
742         if (supported_protocols & NFC_PROTO_FELICA_MASK)
743                 ddev->protocols |= NFC_PROTO_FELICA_MASK;
744         if (supported_protocols & NFC_PROTO_NFC_DEP_MASK)
745                 ddev->protocols |= NFC_PROTO_NFC_DEP_MASK;
746         if (supported_protocols & NFC_PROTO_ISO15693_MASK)
747                 ddev->protocols |= NFC_PROTO_ISO15693_MASK;
748         if (supported_protocols & NFC_PROTO_ISO14443_MASK)
749                 ddev->protocols |= NFC_PROTO_ISO14443_MASK;
750 
751         ddev->tx_headroom = tx_headroom + DIGITAL_MAX_HEADER_LEN;
752         ddev->tx_tailroom = tx_tailroom + DIGITAL_CRC_LEN;
753 
754         ddev->nfc_dev = nfc_allocate_device(&digital_nfc_ops, ddev->protocols,
755                                             ddev->tx_headroom,
756                                             ddev->tx_tailroom);
757         if (!ddev->nfc_dev) {
758                 pr_err("nfc_allocate_device failed\n");
759                 goto free_dev;
760         }
761 
762         nfc_set_drvdata(ddev->nfc_dev, ddev);
763 
764         return ddev;
765 
766 free_dev:
767         kfree(ddev);
768 
769         return NULL;
770 }
771 EXPORT_SYMBOL(nfc_digital_allocate_device);
772 
773 void nfc_digital_free_device(struct nfc_digital_dev *ddev)
774 {
775         nfc_free_device(ddev->nfc_dev);
776         kfree(ddev);
777 }
778 EXPORT_SYMBOL(nfc_digital_free_device);
779 
780 int nfc_digital_register_device(struct nfc_digital_dev *ddev)
781 {
782         return nfc_register_device(ddev->nfc_dev);
783 }
784 EXPORT_SYMBOL(nfc_digital_register_device);
785 
786 void nfc_digital_unregister_device(struct nfc_digital_dev *ddev)
787 {
788         struct digital_cmd *cmd, *n;
789 
790         nfc_unregister_device(ddev->nfc_dev);
791 
792         mutex_lock(&ddev->poll_lock);
793         ddev->poll_tech_count = 0;
794         mutex_unlock(&ddev->poll_lock);
795 
796         cancel_work_sync(&ddev->poll_work);
797         cancel_work_sync(&ddev->cmd_work);
798         cancel_work_sync(&ddev->cmd_complete_work);
799 
800         list_for_each_entry_safe(cmd, n, &ddev->cmd_queue, queue) {
801                 list_del(&cmd->queue);
802                 kfree(cmd->mdaa_params);
803                 kfree(cmd);
804         }
805 }
806 EXPORT_SYMBOL(nfc_digital_unregister_device);
807 
808 MODULE_LICENSE("GPL");
809 

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