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

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

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.14 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.57 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.138 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.193 ] ~ [ 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 // SPDX-License-Identifier: GPL-2.0-or-later
  2 /*
  3  * Copyright (C) 2011 Instituto Nokia de Tecnologia
  4  *
  5  * Authors:
  6  *    Lauro Ramos Venancio <lauro.venancio@openbossa.org>
  7  *    Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
  8  */
  9 
 10 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
 11 
 12 #include <linux/init.h>
 13 #include <linux/kernel.h>
 14 #include <linux/module.h>
 15 #include <linux/slab.h>
 16 #include <linux/rfkill.h>
 17 #include <linux/nfc.h>
 18 
 19 #include <net/genetlink.h>
 20 
 21 #include "nfc.h"
 22 
 23 #define VERSION "0.1"
 24 
 25 #define NFC_CHECK_PRES_FREQ_MS  2000
 26 
 27 int nfc_devlist_generation;
 28 DEFINE_MUTEX(nfc_devlist_mutex);
 29 
 30 /* NFC device ID bitmap */
 31 static DEFINE_IDA(nfc_index_ida);
 32 
 33 int nfc_fw_download(struct nfc_dev *dev, const char *firmware_name)
 34 {
 35         int rc = 0;
 36 
 37         pr_debug("%s do firmware %s\n", dev_name(&dev->dev), firmware_name);
 38 
 39         device_lock(&dev->dev);
 40 
 41         if (!device_is_registered(&dev->dev)) {
 42                 rc = -ENODEV;
 43                 goto error;
 44         }
 45 
 46         if (dev->dev_up) {
 47                 rc = -EBUSY;
 48                 goto error;
 49         }
 50 
 51         if (!dev->ops->fw_download) {
 52                 rc = -EOPNOTSUPP;
 53                 goto error;
 54         }
 55 
 56         dev->fw_download_in_progress = true;
 57         rc = dev->ops->fw_download(dev, firmware_name);
 58         if (rc)
 59                 dev->fw_download_in_progress = false;
 60 
 61 error:
 62         device_unlock(&dev->dev);
 63         return rc;
 64 }
 65 
 66 /**
 67  * nfc_fw_download_done - inform that a firmware download was completed
 68  *
 69  * @dev: The nfc device to which firmware was downloaded
 70  * @firmware_name: The firmware filename
 71  * @result: The positive value of a standard errno value
 72  */
 73 int nfc_fw_download_done(struct nfc_dev *dev, const char *firmware_name,
 74                          u32 result)
 75 {
 76         dev->fw_download_in_progress = false;
 77 
 78         return nfc_genl_fw_download_done(dev, firmware_name, result);
 79 }
 80 EXPORT_SYMBOL(nfc_fw_download_done);
 81 
 82 /**
 83  * nfc_dev_up - turn on the NFC device
 84  *
 85  * @dev: The nfc device to be turned on
 86  *
 87  * The device remains up until the nfc_dev_down function is called.
 88  */
 89 int nfc_dev_up(struct nfc_dev *dev)
 90 {
 91         int rc = 0;
 92 
 93         pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 94 
 95         device_lock(&dev->dev);
 96 
 97         if (dev->rfkill && rfkill_blocked(dev->rfkill)) {
 98                 rc = -ERFKILL;
 99                 goto error;
100         }
101 
102         if (!device_is_registered(&dev->dev)) {
103                 rc = -ENODEV;
104                 goto error;
105         }
106 
107         if (dev->fw_download_in_progress) {
108                 rc = -EBUSY;
109                 goto error;
110         }
111 
112         if (dev->dev_up) {
113                 rc = -EALREADY;
114                 goto error;
115         }
116 
117         if (dev->ops->dev_up)
118                 rc = dev->ops->dev_up(dev);
119 
120         if (!rc)
121                 dev->dev_up = true;
122 
123         /* We have to enable the device before discovering SEs */
124         if (dev->ops->discover_se && dev->ops->discover_se(dev))
125                 pr_err("SE discovery failed\n");
126 
127 error:
128         device_unlock(&dev->dev);
129         return rc;
130 }
131 
132 /**
133  * nfc_dev_down - turn off the NFC device
134  *
135  * @dev: The nfc device to be turned off
136  */
137 int nfc_dev_down(struct nfc_dev *dev)
138 {
139         int rc = 0;
140 
141         pr_debug("dev_name=%s\n", dev_name(&dev->dev));
142 
143         device_lock(&dev->dev);
144 
145         if (!device_is_registered(&dev->dev)) {
146                 rc = -ENODEV;
147                 goto error;
148         }
149 
150         if (!dev->dev_up) {
151                 rc = -EALREADY;
152                 goto error;
153         }
154 
155         if (dev->polling || dev->active_target) {
156                 rc = -EBUSY;
157                 goto error;
158         }
159 
160         if (dev->ops->dev_down)
161                 dev->ops->dev_down(dev);
162 
163         dev->dev_up = false;
164 
165 error:
166         device_unlock(&dev->dev);
167         return rc;
168 }
169 
170 static int nfc_rfkill_set_block(void *data, bool blocked)
171 {
172         struct nfc_dev *dev = data;
173 
174         pr_debug("%s blocked %d", dev_name(&dev->dev), blocked);
175 
176         if (!blocked)
177                 return 0;
178 
179         nfc_dev_down(dev);
180 
181         return 0;
182 }
183 
184 static const struct rfkill_ops nfc_rfkill_ops = {
185         .set_block = nfc_rfkill_set_block,
186 };
187 
188 /**
189  * nfc_start_poll - start polling for nfc targets
190  *
191  * @dev: The nfc device that must start polling
192  * @protocols: bitset of nfc protocols that must be used for polling
193  *
194  * The device remains polling for targets until a target is found or
195  * the nfc_stop_poll function is called.
196  */
197 int nfc_start_poll(struct nfc_dev *dev, u32 im_protocols, u32 tm_protocols)
198 {
199         int rc;
200 
201         pr_debug("dev_name %s initiator protocols 0x%x target protocols 0x%x\n",
202                  dev_name(&dev->dev), im_protocols, tm_protocols);
203 
204         if (!im_protocols && !tm_protocols)
205                 return -EINVAL;
206 
207         device_lock(&dev->dev);
208 
209         if (!device_is_registered(&dev->dev)) {
210                 rc = -ENODEV;
211                 goto error;
212         }
213 
214         if (!dev->dev_up) {
215                 rc = -ENODEV;
216                 goto error;
217         }
218 
219         if (dev->polling) {
220                 rc = -EBUSY;
221                 goto error;
222         }
223 
224         rc = dev->ops->start_poll(dev, im_protocols, tm_protocols);
225         if (!rc) {
226                 dev->polling = true;
227                 dev->rf_mode = NFC_RF_NONE;
228         }
229 
230 error:
231         device_unlock(&dev->dev);
232         return rc;
233 }
234 
235 /**
236  * nfc_stop_poll - stop polling for nfc targets
237  *
238  * @dev: The nfc device that must stop polling
239  */
240 int nfc_stop_poll(struct nfc_dev *dev)
241 {
242         int rc = 0;
243 
244         pr_debug("dev_name=%s\n", dev_name(&dev->dev));
245 
246         device_lock(&dev->dev);
247 
248         if (!device_is_registered(&dev->dev)) {
249                 rc = -ENODEV;
250                 goto error;
251         }
252 
253         if (!dev->polling) {
254                 rc = -EINVAL;
255                 goto error;
256         }
257 
258         dev->ops->stop_poll(dev);
259         dev->polling = false;
260         dev->rf_mode = NFC_RF_NONE;
261 
262 error:
263         device_unlock(&dev->dev);
264         return rc;
265 }
266 
267 static struct nfc_target *nfc_find_target(struct nfc_dev *dev, u32 target_idx)
268 {
269         int i;
270 
271         for (i = 0; i < dev->n_targets; i++) {
272                 if (dev->targets[i].idx == target_idx)
273                         return &dev->targets[i];
274         }
275 
276         return NULL;
277 }
278 
279 int nfc_dep_link_up(struct nfc_dev *dev, int target_index, u8 comm_mode)
280 {
281         int rc = 0;
282         u8 *gb;
283         size_t gb_len;
284         struct nfc_target *target;
285 
286         pr_debug("dev_name=%s comm %d\n", dev_name(&dev->dev), comm_mode);
287 
288         if (!dev->ops->dep_link_up)
289                 return -EOPNOTSUPP;
290 
291         device_lock(&dev->dev);
292 
293         if (!device_is_registered(&dev->dev)) {
294                 rc = -ENODEV;
295                 goto error;
296         }
297 
298         if (dev->dep_link_up == true) {
299                 rc = -EALREADY;
300                 goto error;
301         }
302 
303         gb = nfc_llcp_general_bytes(dev, &gb_len);
304         if (gb_len > NFC_MAX_GT_LEN) {
305                 rc = -EINVAL;
306                 goto error;
307         }
308 
309         target = nfc_find_target(dev, target_index);
310         if (target == NULL) {
311                 rc = -ENOTCONN;
312                 goto error;
313         }
314 
315         rc = dev->ops->dep_link_up(dev, target, comm_mode, gb, gb_len);
316         if (!rc) {
317                 dev->active_target = target;
318                 dev->rf_mode = NFC_RF_INITIATOR;
319         }
320 
321 error:
322         device_unlock(&dev->dev);
323         return rc;
324 }
325 
326 int nfc_dep_link_down(struct nfc_dev *dev)
327 {
328         int rc = 0;
329 
330         pr_debug("dev_name=%s\n", dev_name(&dev->dev));
331 
332         if (!dev->ops->dep_link_down)
333                 return -EOPNOTSUPP;
334 
335         device_lock(&dev->dev);
336 
337         if (!device_is_registered(&dev->dev)) {
338                 rc = -ENODEV;
339                 goto error;
340         }
341 
342         if (dev->dep_link_up == false) {
343                 rc = -EALREADY;
344                 goto error;
345         }
346 
347         rc = dev->ops->dep_link_down(dev);
348         if (!rc) {
349                 dev->dep_link_up = false;
350                 dev->active_target = NULL;
351                 dev->rf_mode = NFC_RF_NONE;
352                 nfc_llcp_mac_is_down(dev);
353                 nfc_genl_dep_link_down_event(dev);
354         }
355 
356 error:
357         device_unlock(&dev->dev);
358 
359         return rc;
360 }
361 
362 int nfc_dep_link_is_up(struct nfc_dev *dev, u32 target_idx,
363                        u8 comm_mode, u8 rf_mode)
364 {
365         dev->dep_link_up = true;
366 
367         if (!dev->active_target && rf_mode == NFC_RF_INITIATOR) {
368                 struct nfc_target *target;
369 
370                 target = nfc_find_target(dev, target_idx);
371                 if (target == NULL)
372                         return -ENOTCONN;
373 
374                 dev->active_target = target;
375         }
376 
377         dev->polling = false;
378         dev->rf_mode = rf_mode;
379 
380         nfc_llcp_mac_is_up(dev, target_idx, comm_mode, rf_mode);
381 
382         return nfc_genl_dep_link_up_event(dev, target_idx, comm_mode, rf_mode);
383 }
384 EXPORT_SYMBOL(nfc_dep_link_is_up);
385 
386 /**
387  * nfc_activate_target - prepare the target for data exchange
388  *
389  * @dev: The nfc device that found the target
390  * @target_idx: index of the target that must be activated
391  * @protocol: nfc protocol that will be used for data exchange
392  */
393 int nfc_activate_target(struct nfc_dev *dev, u32 target_idx, u32 protocol)
394 {
395         int rc;
396         struct nfc_target *target;
397 
398         pr_debug("dev_name=%s target_idx=%u protocol=%u\n",
399                  dev_name(&dev->dev), target_idx, protocol);
400 
401         device_lock(&dev->dev);
402 
403         if (!device_is_registered(&dev->dev)) {
404                 rc = -ENODEV;
405                 goto error;
406         }
407 
408         if (dev->active_target) {
409                 rc = -EBUSY;
410                 goto error;
411         }
412 
413         target = nfc_find_target(dev, target_idx);
414         if (target == NULL) {
415                 rc = -ENOTCONN;
416                 goto error;
417         }
418 
419         rc = dev->ops->activate_target(dev, target, protocol);
420         if (!rc) {
421                 dev->active_target = target;
422                 dev->rf_mode = NFC_RF_INITIATOR;
423 
424                 if (dev->ops->check_presence && !dev->shutting_down)
425                         mod_timer(&dev->check_pres_timer, jiffies +
426                                   msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
427         }
428 
429 error:
430         device_unlock(&dev->dev);
431         return rc;
432 }
433 
434 /**
435  * nfc_deactivate_target - deactivate a nfc target
436  *
437  * @dev: The nfc device that found the target
438  * @target_idx: index of the target that must be deactivated
439  */
440 int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx, u8 mode)
441 {
442         int rc = 0;
443 
444         pr_debug("dev_name=%s target_idx=%u\n",
445                  dev_name(&dev->dev), target_idx);
446 
447         device_lock(&dev->dev);
448 
449         if (!device_is_registered(&dev->dev)) {
450                 rc = -ENODEV;
451                 goto error;
452         }
453 
454         if (dev->active_target == NULL) {
455                 rc = -ENOTCONN;
456                 goto error;
457         }
458 
459         if (dev->active_target->idx != target_idx) {
460                 rc = -ENOTCONN;
461                 goto error;
462         }
463 
464         if (dev->ops->check_presence)
465                 del_timer_sync(&dev->check_pres_timer);
466 
467         dev->ops->deactivate_target(dev, dev->active_target, mode);
468         dev->active_target = NULL;
469 
470 error:
471         device_unlock(&dev->dev);
472         return rc;
473 }
474 
475 /**
476  * nfc_data_exchange - transceive data
477  *
478  * @dev: The nfc device that found the target
479  * @target_idx: index of the target
480  * @skb: data to be sent
481  * @cb: callback called when the response is received
482  * @cb_context: parameter for the callback function
483  *
484  * The user must wait for the callback before calling this function again.
485  */
486 int nfc_data_exchange(struct nfc_dev *dev, u32 target_idx, struct sk_buff *skb,
487                       data_exchange_cb_t cb, void *cb_context)
488 {
489         int rc;
490 
491         pr_debug("dev_name=%s target_idx=%u skb->len=%u\n",
492                  dev_name(&dev->dev), target_idx, skb->len);
493 
494         device_lock(&dev->dev);
495 
496         if (!device_is_registered(&dev->dev)) {
497                 rc = -ENODEV;
498                 kfree_skb(skb);
499                 goto error;
500         }
501 
502         if (dev->rf_mode == NFC_RF_INITIATOR && dev->active_target != NULL) {
503                 if (dev->active_target->idx != target_idx) {
504                         rc = -EADDRNOTAVAIL;
505                         kfree_skb(skb);
506                         goto error;
507                 }
508 
509                 if (dev->ops->check_presence)
510                         del_timer_sync(&dev->check_pres_timer);
511 
512                 rc = dev->ops->im_transceive(dev, dev->active_target, skb, cb,
513                                              cb_context);
514 
515                 if (!rc && dev->ops->check_presence && !dev->shutting_down)
516                         mod_timer(&dev->check_pres_timer, jiffies +
517                                   msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
518         } else if (dev->rf_mode == NFC_RF_TARGET && dev->ops->tm_send != NULL) {
519                 rc = dev->ops->tm_send(dev, skb);
520         } else {
521                 rc = -ENOTCONN;
522                 kfree_skb(skb);
523                 goto error;
524         }
525 
526 
527 error:
528         device_unlock(&dev->dev);
529         return rc;
530 }
531 
532 struct nfc_se *nfc_find_se(struct nfc_dev *dev, u32 se_idx)
533 {
534         struct nfc_se *se;
535 
536         list_for_each_entry(se, &dev->secure_elements, list)
537                 if (se->idx == se_idx)
538                         return se;
539 
540         return NULL;
541 }
542 EXPORT_SYMBOL(nfc_find_se);
543 
544 int nfc_enable_se(struct nfc_dev *dev, u32 se_idx)
545 {
546         struct nfc_se *se;
547         int rc;
548 
549         pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
550 
551         device_lock(&dev->dev);
552 
553         if (!device_is_registered(&dev->dev)) {
554                 rc = -ENODEV;
555                 goto error;
556         }
557 
558         if (!dev->dev_up) {
559                 rc = -ENODEV;
560                 goto error;
561         }
562 
563         if (dev->polling) {
564                 rc = -EBUSY;
565                 goto error;
566         }
567 
568         if (!dev->ops->enable_se || !dev->ops->disable_se) {
569                 rc = -EOPNOTSUPP;
570                 goto error;
571         }
572 
573         se = nfc_find_se(dev, se_idx);
574         if (!se) {
575                 rc = -EINVAL;
576                 goto error;
577         }
578 
579         if (se->state == NFC_SE_ENABLED) {
580                 rc = -EALREADY;
581                 goto error;
582         }
583 
584         rc = dev->ops->enable_se(dev, se_idx);
585         if (rc >= 0)
586                 se->state = NFC_SE_ENABLED;
587 
588 error:
589         device_unlock(&dev->dev);
590         return rc;
591 }
592 
593 int nfc_disable_se(struct nfc_dev *dev, u32 se_idx)
594 {
595         struct nfc_se *se;
596         int rc;
597 
598         pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
599 
600         device_lock(&dev->dev);
601 
602         if (!device_is_registered(&dev->dev)) {
603                 rc = -ENODEV;
604                 goto error;
605         }
606 
607         if (!dev->dev_up) {
608                 rc = -ENODEV;
609                 goto error;
610         }
611 
612         if (!dev->ops->enable_se || !dev->ops->disable_se) {
613                 rc = -EOPNOTSUPP;
614                 goto error;
615         }
616 
617         se = nfc_find_se(dev, se_idx);
618         if (!se) {
619                 rc = -EINVAL;
620                 goto error;
621         }
622 
623         if (se->state == NFC_SE_DISABLED) {
624                 rc = -EALREADY;
625                 goto error;
626         }
627 
628         rc = dev->ops->disable_se(dev, se_idx);
629         if (rc >= 0)
630                 se->state = NFC_SE_DISABLED;
631 
632 error:
633         device_unlock(&dev->dev);
634         return rc;
635 }
636 
637 int nfc_set_remote_general_bytes(struct nfc_dev *dev, u8 *gb, u8 gb_len)
638 {
639         pr_debug("dev_name=%s gb_len=%d\n", dev_name(&dev->dev), gb_len);
640 
641         return nfc_llcp_set_remote_gb(dev, gb, gb_len);
642 }
643 EXPORT_SYMBOL(nfc_set_remote_general_bytes);
644 
645 u8 *nfc_get_local_general_bytes(struct nfc_dev *dev, size_t *gb_len)
646 {
647         pr_debug("dev_name=%s\n", dev_name(&dev->dev));
648 
649         return nfc_llcp_general_bytes(dev, gb_len);
650 }
651 EXPORT_SYMBOL(nfc_get_local_general_bytes);
652 
653 int nfc_tm_data_received(struct nfc_dev *dev, struct sk_buff *skb)
654 {
655         /* Only LLCP target mode for now */
656         if (dev->dep_link_up == false) {
657                 kfree_skb(skb);
658                 return -ENOLINK;
659         }
660 
661         return nfc_llcp_data_received(dev, skb);
662 }
663 EXPORT_SYMBOL(nfc_tm_data_received);
664 
665 int nfc_tm_activated(struct nfc_dev *dev, u32 protocol, u8 comm_mode,
666                      u8 *gb, size_t gb_len)
667 {
668         int rc;
669 
670         device_lock(&dev->dev);
671 
672         dev->polling = false;
673 
674         if (gb != NULL) {
675                 rc = nfc_set_remote_general_bytes(dev, gb, gb_len);
676                 if (rc < 0)
677                         goto out;
678         }
679 
680         dev->rf_mode = NFC_RF_TARGET;
681 
682         if (protocol == NFC_PROTO_NFC_DEP_MASK)
683                 nfc_dep_link_is_up(dev, 0, comm_mode, NFC_RF_TARGET);
684 
685         rc = nfc_genl_tm_activated(dev, protocol);
686 
687 out:
688         device_unlock(&dev->dev);
689 
690         return rc;
691 }
692 EXPORT_SYMBOL(nfc_tm_activated);
693 
694 int nfc_tm_deactivated(struct nfc_dev *dev)
695 {
696         dev->dep_link_up = false;
697         dev->rf_mode = NFC_RF_NONE;
698 
699         return nfc_genl_tm_deactivated(dev);
700 }
701 EXPORT_SYMBOL(nfc_tm_deactivated);
702 
703 /**
704  * nfc_alloc_send_skb - allocate a skb for data exchange responses
705  *
706  * @size: size to allocate
707  * @gfp: gfp flags
708  */
709 struct sk_buff *nfc_alloc_send_skb(struct nfc_dev *dev, struct sock *sk,
710                                    unsigned int flags, unsigned int size,
711                                    unsigned int *err)
712 {
713         struct sk_buff *skb;
714         unsigned int total_size;
715 
716         total_size = size +
717                 dev->tx_headroom + dev->tx_tailroom + NFC_HEADER_SIZE;
718 
719         skb = sock_alloc_send_skb(sk, total_size, flags & MSG_DONTWAIT, err);
720         if (skb)
721                 skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE);
722 
723         return skb;
724 }
725 
726 /**
727  * nfc_alloc_recv_skb - allocate a skb for data exchange responses
728  *
729  * @size: size to allocate
730  * @gfp: gfp flags
731  */
732 struct sk_buff *nfc_alloc_recv_skb(unsigned int size, gfp_t gfp)
733 {
734         struct sk_buff *skb;
735         unsigned int total_size;
736 
737         total_size = size + 1;
738         skb = alloc_skb(total_size, gfp);
739 
740         if (skb)
741                 skb_reserve(skb, 1);
742 
743         return skb;
744 }
745 EXPORT_SYMBOL(nfc_alloc_recv_skb);
746 
747 /**
748  * nfc_targets_found - inform that targets were found
749  *
750  * @dev: The nfc device that found the targets
751  * @targets: array of nfc targets found
752  * @ntargets: targets array size
753  *
754  * The device driver must call this function when one or many nfc targets
755  * are found. After calling this function, the device driver must stop
756  * polling for targets.
757  * NOTE: This function can be called with targets=NULL and n_targets=0 to
758  * notify a driver error, meaning that the polling operation cannot complete.
759  * IMPORTANT: this function must not be called from an atomic context.
760  * In addition, it must also not be called from a context that would prevent
761  * the NFC Core to call other nfc ops entry point concurrently.
762  */
763 int nfc_targets_found(struct nfc_dev *dev,
764                       struct nfc_target *targets, int n_targets)
765 {
766         int i;
767 
768         pr_debug("dev_name=%s n_targets=%d\n", dev_name(&dev->dev), n_targets);
769 
770         for (i = 0; i < n_targets; i++)
771                 targets[i].idx = dev->target_next_idx++;
772 
773         device_lock(&dev->dev);
774 
775         if (dev->polling == false) {
776                 device_unlock(&dev->dev);
777                 return 0;
778         }
779 
780         dev->polling = false;
781 
782         dev->targets_generation++;
783 
784         kfree(dev->targets);
785         dev->targets = NULL;
786 
787         if (targets) {
788                 dev->targets = kmemdup(targets,
789                                        n_targets * sizeof(struct nfc_target),
790                                        GFP_ATOMIC);
791 
792                 if (!dev->targets) {
793                         dev->n_targets = 0;
794                         device_unlock(&dev->dev);
795                         return -ENOMEM;
796                 }
797         }
798 
799         dev->n_targets = n_targets;
800         device_unlock(&dev->dev);
801 
802         nfc_genl_targets_found(dev);
803 
804         return 0;
805 }
806 EXPORT_SYMBOL(nfc_targets_found);
807 
808 /**
809  * nfc_target_lost - inform that an activated target went out of field
810  *
811  * @dev: The nfc device that had the activated target in field
812  * @target_idx: the nfc index of the target
813  *
814  * The device driver must call this function when the activated target
815  * goes out of the field.
816  * IMPORTANT: this function must not be called from an atomic context.
817  * In addition, it must also not be called from a context that would prevent
818  * the NFC Core to call other nfc ops entry point concurrently.
819  */
820 int nfc_target_lost(struct nfc_dev *dev, u32 target_idx)
821 {
822         struct nfc_target *tg;
823         int i;
824 
825         pr_debug("dev_name %s n_target %d\n", dev_name(&dev->dev), target_idx);
826 
827         device_lock(&dev->dev);
828 
829         for (i = 0; i < dev->n_targets; i++) {
830                 tg = &dev->targets[i];
831                 if (tg->idx == target_idx)
832                         break;
833         }
834 
835         if (i == dev->n_targets) {
836                 device_unlock(&dev->dev);
837                 return -EINVAL;
838         }
839 
840         dev->targets_generation++;
841         dev->n_targets--;
842         dev->active_target = NULL;
843 
844         if (dev->n_targets) {
845                 memcpy(&dev->targets[i], &dev->targets[i + 1],
846                        (dev->n_targets - i) * sizeof(struct nfc_target));
847         } else {
848                 kfree(dev->targets);
849                 dev->targets = NULL;
850         }
851 
852         device_unlock(&dev->dev);
853 
854         nfc_genl_target_lost(dev, target_idx);
855 
856         return 0;
857 }
858 EXPORT_SYMBOL(nfc_target_lost);
859 
860 inline void nfc_driver_failure(struct nfc_dev *dev, int err)
861 {
862         nfc_targets_found(dev, NULL, 0);
863 }
864 EXPORT_SYMBOL(nfc_driver_failure);
865 
866 int nfc_add_se(struct nfc_dev *dev, u32 se_idx, u16 type)
867 {
868         struct nfc_se *se;
869         int rc;
870 
871         pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
872 
873         se = nfc_find_se(dev, se_idx);
874         if (se)
875                 return -EALREADY;
876 
877         se = kzalloc(sizeof(struct nfc_se), GFP_KERNEL);
878         if (!se)
879                 return -ENOMEM;
880 
881         se->idx = se_idx;
882         se->type = type;
883         se->state = NFC_SE_DISABLED;
884         INIT_LIST_HEAD(&se->list);
885 
886         list_add(&se->list, &dev->secure_elements);
887 
888         rc = nfc_genl_se_added(dev, se_idx, type);
889         if (rc < 0) {
890                 list_del(&se->list);
891                 kfree(se);
892 
893                 return rc;
894         }
895 
896         return 0;
897 }
898 EXPORT_SYMBOL(nfc_add_se);
899 
900 int nfc_remove_se(struct nfc_dev *dev, u32 se_idx)
901 {
902         struct nfc_se *se, *n;
903         int rc;
904 
905         pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
906 
907         list_for_each_entry_safe(se, n, &dev->secure_elements, list)
908                 if (se->idx == se_idx) {
909                         rc = nfc_genl_se_removed(dev, se_idx);
910                         if (rc < 0)
911                                 return rc;
912 
913                         list_del(&se->list);
914                         kfree(se);
915 
916                         return 0;
917                 }
918 
919         return -EINVAL;
920 }
921 EXPORT_SYMBOL(nfc_remove_se);
922 
923 int nfc_se_transaction(struct nfc_dev *dev, u8 se_idx,
924                        struct nfc_evt_transaction *evt_transaction)
925 {
926         int rc;
927 
928         pr_debug("transaction: %x\n", se_idx);
929 
930         device_lock(&dev->dev);
931 
932         if (!evt_transaction) {
933                 rc = -EPROTO;
934                 goto out;
935         }
936 
937         rc = nfc_genl_se_transaction(dev, se_idx, evt_transaction);
938 out:
939         device_unlock(&dev->dev);
940         return rc;
941 }
942 EXPORT_SYMBOL(nfc_se_transaction);
943 
944 int nfc_se_connectivity(struct nfc_dev *dev, u8 se_idx)
945 {
946         int rc;
947 
948         pr_debug("connectivity: %x\n", se_idx);
949 
950         device_lock(&dev->dev);
951         rc = nfc_genl_se_connectivity(dev, se_idx);
952         device_unlock(&dev->dev);
953         return rc;
954 }
955 EXPORT_SYMBOL(nfc_se_connectivity);
956 
957 static void nfc_release(struct device *d)
958 {
959         struct nfc_dev *dev = to_nfc_dev(d);
960         struct nfc_se *se, *n;
961 
962         pr_debug("dev_name=%s\n", dev_name(&dev->dev));
963 
964         nfc_genl_data_exit(&dev->genl_data);
965         kfree(dev->targets);
966 
967         list_for_each_entry_safe(se, n, &dev->secure_elements, list) {
968                         nfc_genl_se_removed(dev, se->idx);
969                         list_del(&se->list);
970                         kfree(se);
971         }
972 
973         ida_simple_remove(&nfc_index_ida, dev->idx);
974 
975         kfree(dev);
976 }
977 
978 static void nfc_check_pres_work(struct work_struct *work)
979 {
980         struct nfc_dev *dev = container_of(work, struct nfc_dev,
981                                            check_pres_work);
982         int rc;
983 
984         device_lock(&dev->dev);
985 
986         if (dev->active_target && timer_pending(&dev->check_pres_timer) == 0) {
987                 rc = dev->ops->check_presence(dev, dev->active_target);
988                 if (rc == -EOPNOTSUPP)
989                         goto exit;
990                 if (rc) {
991                         u32 active_target_idx = dev->active_target->idx;
992                         device_unlock(&dev->dev);
993                         nfc_target_lost(dev, active_target_idx);
994                         return;
995                 }
996 
997                 if (!dev->shutting_down)
998                         mod_timer(&dev->check_pres_timer, jiffies +
999                                   msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
1000         }
1001 
1002 exit:
1003         device_unlock(&dev->dev);
1004 }
1005 
1006 static void nfc_check_pres_timeout(struct timer_list *t)
1007 {
1008         struct nfc_dev *dev = from_timer(dev, t, check_pres_timer);
1009 
1010         schedule_work(&dev->check_pres_work);
1011 }
1012 
1013 struct class nfc_class = {
1014         .name = "nfc",
1015         .dev_release = nfc_release,
1016 };
1017 EXPORT_SYMBOL(nfc_class);
1018 
1019 static int match_idx(struct device *d, const void *data)
1020 {
1021         struct nfc_dev *dev = to_nfc_dev(d);
1022         const unsigned int *idx = data;
1023 
1024         return dev->idx == *idx;
1025 }
1026 
1027 struct nfc_dev *nfc_get_device(unsigned int idx)
1028 {
1029         struct device *d;
1030 
1031         d = class_find_device(&nfc_class, NULL, &idx, match_idx);
1032         if (!d)
1033                 return NULL;
1034 
1035         return to_nfc_dev(d);
1036 }
1037 
1038 /**
1039  * nfc_allocate_device - allocate a new nfc device
1040  *
1041  * @ops: device operations
1042  * @supported_protocols: NFC protocols supported by the device
1043  */
1044 struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops,
1045                                     u32 supported_protocols,
1046                                     int tx_headroom, int tx_tailroom)
1047 {
1048         struct nfc_dev *dev;
1049         int rc;
1050 
1051         if (!ops->start_poll || !ops->stop_poll || !ops->activate_target ||
1052             !ops->deactivate_target || !ops->im_transceive)
1053                 return NULL;
1054 
1055         if (!supported_protocols)
1056                 return NULL;
1057 
1058         dev = kzalloc(sizeof(struct nfc_dev), GFP_KERNEL);
1059         if (!dev)
1060                 return NULL;
1061 
1062         rc = ida_simple_get(&nfc_index_ida, 0, 0, GFP_KERNEL);
1063         if (rc < 0)
1064                 goto err_free_dev;
1065         dev->idx = rc;
1066 
1067         dev->dev.class = &nfc_class;
1068         dev_set_name(&dev->dev, "nfc%d", dev->idx);
1069         device_initialize(&dev->dev);
1070 
1071         dev->ops = ops;
1072         dev->supported_protocols = supported_protocols;
1073         dev->tx_headroom = tx_headroom;
1074         dev->tx_tailroom = tx_tailroom;
1075         INIT_LIST_HEAD(&dev->secure_elements);
1076 
1077         nfc_genl_data_init(&dev->genl_data);
1078 
1079         dev->rf_mode = NFC_RF_NONE;
1080 
1081         /* first generation must not be 0 */
1082         dev->targets_generation = 1;
1083 
1084         if (ops->check_presence) {
1085                 timer_setup(&dev->check_pres_timer, nfc_check_pres_timeout, 0);
1086                 INIT_WORK(&dev->check_pres_work, nfc_check_pres_work);
1087         }
1088 
1089         return dev;
1090 
1091 err_free_dev:
1092         kfree(dev);
1093 
1094         return NULL;
1095 }
1096 EXPORT_SYMBOL(nfc_allocate_device);
1097 
1098 /**
1099  * nfc_register_device - register a nfc device in the nfc subsystem
1100  *
1101  * @dev: The nfc device to register
1102  */
1103 int nfc_register_device(struct nfc_dev *dev)
1104 {
1105         int rc;
1106 
1107         pr_debug("dev_name=%s\n", dev_name(&dev->dev));
1108 
1109         mutex_lock(&nfc_devlist_mutex);
1110         nfc_devlist_generation++;
1111         rc = device_add(&dev->dev);
1112         mutex_unlock(&nfc_devlist_mutex);
1113 
1114         if (rc < 0)
1115                 return rc;
1116 
1117         rc = nfc_llcp_register_device(dev);
1118         if (rc)
1119                 pr_err("Could not register llcp device\n");
1120 
1121         rc = nfc_genl_device_added(dev);
1122         if (rc)
1123                 pr_debug("The userspace won't be notified that the device %s was added\n",
1124                          dev_name(&dev->dev));
1125 
1126         dev->rfkill = rfkill_alloc(dev_name(&dev->dev), &dev->dev,
1127                                    RFKILL_TYPE_NFC, &nfc_rfkill_ops, dev);
1128         if (dev->rfkill) {
1129                 if (rfkill_register(dev->rfkill) < 0) {
1130                         rfkill_destroy(dev->rfkill);
1131                         dev->rfkill = NULL;
1132                 }
1133         }
1134 
1135         return 0;
1136 }
1137 EXPORT_SYMBOL(nfc_register_device);
1138 
1139 /**
1140  * nfc_unregister_device - unregister a nfc device in the nfc subsystem
1141  *
1142  * @dev: The nfc device to unregister
1143  */
1144 void nfc_unregister_device(struct nfc_dev *dev)
1145 {
1146         int rc;
1147 
1148         pr_debug("dev_name=%s\n", dev_name(&dev->dev));
1149 
1150         if (dev->rfkill) {
1151                 rfkill_unregister(dev->rfkill);
1152                 rfkill_destroy(dev->rfkill);
1153         }
1154 
1155         if (dev->ops->check_presence) {
1156                 device_lock(&dev->dev);
1157                 dev->shutting_down = true;
1158                 device_unlock(&dev->dev);
1159                 del_timer_sync(&dev->check_pres_timer);
1160                 cancel_work_sync(&dev->check_pres_work);
1161         }
1162 
1163         rc = nfc_genl_device_removed(dev);
1164         if (rc)
1165                 pr_debug("The userspace won't be notified that the device %s "
1166                          "was removed\n", dev_name(&dev->dev));
1167 
1168         nfc_llcp_unregister_device(dev);
1169 
1170         mutex_lock(&nfc_devlist_mutex);
1171         nfc_devlist_generation++;
1172         device_del(&dev->dev);
1173         mutex_unlock(&nfc_devlist_mutex);
1174 }
1175 EXPORT_SYMBOL(nfc_unregister_device);
1176 
1177 static int __init nfc_init(void)
1178 {
1179         int rc;
1180 
1181         pr_info("NFC Core ver %s\n", VERSION);
1182 
1183         rc = class_register(&nfc_class);
1184         if (rc)
1185                 return rc;
1186 
1187         rc = nfc_genl_init();
1188         if (rc)
1189                 goto err_genl;
1190 
1191         /* the first generation must not be 0 */
1192         nfc_devlist_generation = 1;
1193 
1194         rc = rawsock_init();
1195         if (rc)
1196                 goto err_rawsock;
1197 
1198         rc = nfc_llcp_init();
1199         if (rc)
1200                 goto err_llcp_sock;
1201 
1202         rc = af_nfc_init();
1203         if (rc)
1204                 goto err_af_nfc;
1205 
1206         return 0;
1207 
1208 err_af_nfc:
1209         nfc_llcp_exit();
1210 err_llcp_sock:
1211         rawsock_exit();
1212 err_rawsock:
1213         nfc_genl_exit();
1214 err_genl:
1215         class_unregister(&nfc_class);
1216         return rc;
1217 }
1218 
1219 static void __exit nfc_exit(void)
1220 {
1221         af_nfc_exit();
1222         nfc_llcp_exit();
1223         rawsock_exit();
1224         nfc_genl_exit();
1225         class_unregister(&nfc_class);
1226 }
1227 
1228 subsys_initcall(nfc_init);
1229 module_exit(nfc_exit);
1230 
1231 MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
1232 MODULE_DESCRIPTION("NFC Core ver " VERSION);
1233 MODULE_VERSION(VERSION);
1234 MODULE_LICENSE("GPL");
1235 MODULE_ALIAS_NETPROTO(PF_NFC);
1236 MODULE_ALIAS_GENL_FAMILY(NFC_GENL_NAME);
1237 

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