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

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

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ 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.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

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