2 * Copyright (C) 2011 Instituto Nokia de Tecnologia
5 * Lauro Ramos Venancio <lauro.venancio@openbossa.org>
6 * Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
8 * Vendor commands implementation based on net/wireless/nl80211.c
11 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
12 * Copyright 2013-2014 Intel Mobile Communications GmbH
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, see <http://www.gnu.org/licenses/>.
28 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
30 #include <net/genetlink.h>
31 #include <linux/nfc.h>
32 #include <linux/slab.h>
37 static const struct genl_multicast_group nfc_genl_mcgrps
[] = {
38 { .name
= NFC_GENL_MCAST_EVENT_NAME
, },
41 static struct genl_family nfc_genl_family
;
42 static const struct nla_policy nfc_genl_policy
[NFC_ATTR_MAX
+ 1] = {
43 [NFC_ATTR_DEVICE_INDEX
] = { .type
= NLA_U32
},
44 [NFC_ATTR_DEVICE_NAME
] = { .type
= NLA_STRING
,
45 .len
= NFC_DEVICE_NAME_MAXSIZE
},
46 [NFC_ATTR_PROTOCOLS
] = { .type
= NLA_U32
},
47 [NFC_ATTR_COMM_MODE
] = { .type
= NLA_U8
},
48 [NFC_ATTR_RF_MODE
] = { .type
= NLA_U8
},
49 [NFC_ATTR_DEVICE_POWERED
] = { .type
= NLA_U8
},
50 [NFC_ATTR_IM_PROTOCOLS
] = { .type
= NLA_U32
},
51 [NFC_ATTR_TM_PROTOCOLS
] = { .type
= NLA_U32
},
52 [NFC_ATTR_LLC_PARAM_LTO
] = { .type
= NLA_U8
},
53 [NFC_ATTR_LLC_PARAM_RW
] = { .type
= NLA_U8
},
54 [NFC_ATTR_LLC_PARAM_MIUX
] = { .type
= NLA_U16
},
55 [NFC_ATTR_LLC_SDP
] = { .type
= NLA_NESTED
},
56 [NFC_ATTR_FIRMWARE_NAME
] = { .type
= NLA_STRING
,
57 .len
= NFC_FIRMWARE_NAME_MAXSIZE
},
58 [NFC_ATTR_SE_APDU
] = { .type
= NLA_BINARY
},
59 [NFC_ATTR_VENDOR_DATA
] = { .type
= NLA_BINARY
},
63 static const struct nla_policy nfc_sdp_genl_policy
[NFC_SDP_ATTR_MAX
+ 1] = {
64 [NFC_SDP_ATTR_URI
] = { .type
= NLA_STRING
,
66 [NFC_SDP_ATTR_SAP
] = { .type
= NLA_U8
},
69 static int nfc_genl_send_target(struct sk_buff
*msg
, struct nfc_target
*target
,
70 struct netlink_callback
*cb
, int flags
)
74 hdr
= genlmsg_put(msg
, NETLINK_CB(cb
->skb
).portid
, cb
->nlh
->nlmsg_seq
,
75 &nfc_genl_family
, flags
, NFC_CMD_GET_TARGET
);
79 genl_dump_check_consistent(cb
, hdr
, &nfc_genl_family
);
81 if (nla_put_u32(msg
, NFC_ATTR_TARGET_INDEX
, target
->idx
) ||
82 nla_put_u32(msg
, NFC_ATTR_PROTOCOLS
, target
->supported_protocols
) ||
83 nla_put_u16(msg
, NFC_ATTR_TARGET_SENS_RES
, target
->sens_res
) ||
84 nla_put_u8(msg
, NFC_ATTR_TARGET_SEL_RES
, target
->sel_res
))
86 if (target
->nfcid1_len
> 0 &&
87 nla_put(msg
, NFC_ATTR_TARGET_NFCID1
, target
->nfcid1_len
,
90 if (target
->sensb_res_len
> 0 &&
91 nla_put(msg
, NFC_ATTR_TARGET_SENSB_RES
, target
->sensb_res_len
,
94 if (target
->sensf_res_len
> 0 &&
95 nla_put(msg
, NFC_ATTR_TARGET_SENSF_RES
, target
->sensf_res_len
,
99 if (target
->is_iso15693
) {
100 if (nla_put_u8(msg
, NFC_ATTR_TARGET_ISO15693_DSFID
,
101 target
->iso15693_dsfid
) ||
102 nla_put(msg
, NFC_ATTR_TARGET_ISO15693_UID
,
103 sizeof(target
->iso15693_uid
), target
->iso15693_uid
))
104 goto nla_put_failure
;
107 genlmsg_end(msg
, hdr
);
111 genlmsg_cancel(msg
, hdr
);
115 static struct nfc_dev
*__get_device_from_cb(struct netlink_callback
*cb
)
117 struct nlattr
**attrbuf
= genl_family_attrbuf(&nfc_genl_family
);
122 rc
= nlmsg_parse(cb
->nlh
, GENL_HDRLEN
+ nfc_genl_family
.hdrsize
,
123 attrbuf
, nfc_genl_family
.maxattr
, nfc_genl_policy
,
128 if (!attrbuf
[NFC_ATTR_DEVICE_INDEX
])
129 return ERR_PTR(-EINVAL
);
131 idx
= nla_get_u32(attrbuf
[NFC_ATTR_DEVICE_INDEX
]);
133 dev
= nfc_get_device(idx
);
135 return ERR_PTR(-ENODEV
);
140 static int nfc_genl_dump_targets(struct sk_buff
*skb
,
141 struct netlink_callback
*cb
)
144 struct nfc_dev
*dev
= (struct nfc_dev
*) cb
->args
[1];
148 dev
= __get_device_from_cb(cb
);
152 cb
->args
[1] = (long) dev
;
155 device_lock(&dev
->dev
);
157 cb
->seq
= dev
->targets_generation
;
159 while (i
< dev
->n_targets
) {
160 rc
= nfc_genl_send_target(skb
, &dev
->targets
[i
], cb
,
168 device_unlock(&dev
->dev
);
175 static int nfc_genl_dump_targets_done(struct netlink_callback
*cb
)
177 struct nfc_dev
*dev
= (struct nfc_dev
*) cb
->args
[1];
185 int nfc_genl_targets_found(struct nfc_dev
*dev
)
190 dev
->genl_data
.poll_req_portid
= 0;
192 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
196 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
197 NFC_EVENT_TARGETS_FOUND
);
201 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
202 goto nla_put_failure
;
204 genlmsg_end(msg
, hdr
);
206 return genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_ATOMIC
);
209 genlmsg_cancel(msg
, hdr
);
215 int nfc_genl_target_lost(struct nfc_dev
*dev
, u32 target_idx
)
220 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
224 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
225 NFC_EVENT_TARGET_LOST
);
229 if (nla_put_string(msg
, NFC_ATTR_DEVICE_NAME
, nfc_device_name(dev
)) ||
230 nla_put_u32(msg
, NFC_ATTR_TARGET_INDEX
, target_idx
))
231 goto nla_put_failure
;
233 genlmsg_end(msg
, hdr
);
235 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
240 genlmsg_cancel(msg
, hdr
);
246 int nfc_genl_tm_activated(struct nfc_dev
*dev
, u32 protocol
)
251 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
255 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
256 NFC_EVENT_TM_ACTIVATED
);
260 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
261 goto nla_put_failure
;
262 if (nla_put_u32(msg
, NFC_ATTR_TM_PROTOCOLS
, protocol
))
263 goto nla_put_failure
;
265 genlmsg_end(msg
, hdr
);
267 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
272 genlmsg_cancel(msg
, hdr
);
278 int nfc_genl_tm_deactivated(struct nfc_dev
*dev
)
283 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
287 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
288 NFC_EVENT_TM_DEACTIVATED
);
292 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
293 goto nla_put_failure
;
295 genlmsg_end(msg
, hdr
);
297 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
302 genlmsg_cancel(msg
, hdr
);
308 static int nfc_genl_setup_device_added(struct nfc_dev
*dev
, struct sk_buff
*msg
)
310 if (nla_put_string(msg
, NFC_ATTR_DEVICE_NAME
, nfc_device_name(dev
)) ||
311 nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
312 nla_put_u32(msg
, NFC_ATTR_PROTOCOLS
, dev
->supported_protocols
) ||
313 nla_put_u8(msg
, NFC_ATTR_DEVICE_POWERED
, dev
->dev_up
) ||
314 nla_put_u8(msg
, NFC_ATTR_RF_MODE
, dev
->rf_mode
))
319 int nfc_genl_device_added(struct nfc_dev
*dev
)
324 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
328 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
329 NFC_EVENT_DEVICE_ADDED
);
333 if (nfc_genl_setup_device_added(dev
, msg
))
334 goto nla_put_failure
;
336 genlmsg_end(msg
, hdr
);
338 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
343 genlmsg_cancel(msg
, hdr
);
349 int nfc_genl_device_removed(struct nfc_dev
*dev
)
354 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
358 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
359 NFC_EVENT_DEVICE_REMOVED
);
363 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
364 goto nla_put_failure
;
366 genlmsg_end(msg
, hdr
);
368 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
373 genlmsg_cancel(msg
, hdr
);
379 int nfc_genl_llc_send_sdres(struct nfc_dev
*dev
, struct hlist_head
*sdres_list
)
382 struct nlattr
*sdp_attr
, *uri_attr
;
383 struct nfc_llcp_sdp_tlv
*sdres
;
384 struct hlist_node
*n
;
389 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
393 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
394 NFC_EVENT_LLC_SDRES
);
398 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
399 goto nla_put_failure
;
401 sdp_attr
= nla_nest_start(msg
, NFC_ATTR_LLC_SDP
);
402 if (sdp_attr
== NULL
) {
404 goto nla_put_failure
;
408 hlist_for_each_entry_safe(sdres
, n
, sdres_list
, node
) {
409 pr_debug("uri: %s, sap: %d\n", sdres
->uri
, sdres
->sap
);
411 uri_attr
= nla_nest_start(msg
, i
++);
412 if (uri_attr
== NULL
) {
414 goto nla_put_failure
;
417 if (nla_put_u8(msg
, NFC_SDP_ATTR_SAP
, sdres
->sap
))
418 goto nla_put_failure
;
420 if (nla_put_string(msg
, NFC_SDP_ATTR_URI
, sdres
->uri
))
421 goto nla_put_failure
;
423 nla_nest_end(msg
, uri_attr
);
425 hlist_del(&sdres
->node
);
427 nfc_llcp_free_sdp_tlv(sdres
);
430 nla_nest_end(msg
, sdp_attr
);
432 genlmsg_end(msg
, hdr
);
434 return genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_ATOMIC
);
437 genlmsg_cancel(msg
, hdr
);
442 nfc_llcp_free_sdp_tlv_list(sdres_list
);
447 int nfc_genl_se_added(struct nfc_dev
*dev
, u32 se_idx
, u16 type
)
452 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
456 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
461 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
462 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se_idx
) ||
463 nla_put_u8(msg
, NFC_ATTR_SE_TYPE
, type
))
464 goto nla_put_failure
;
466 genlmsg_end(msg
, hdr
);
468 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
473 genlmsg_cancel(msg
, hdr
);
479 int nfc_genl_se_removed(struct nfc_dev
*dev
, u32 se_idx
)
484 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
488 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
489 NFC_EVENT_SE_REMOVED
);
493 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
494 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se_idx
))
495 goto nla_put_failure
;
497 genlmsg_end(msg
, hdr
);
499 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
504 genlmsg_cancel(msg
, hdr
);
510 int nfc_genl_se_transaction(struct nfc_dev
*dev
, u8 se_idx
,
511 struct nfc_evt_transaction
*evt_transaction
)
517 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
521 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
522 NFC_EVENT_SE_TRANSACTION
);
526 se
= nfc_find_se(dev
, se_idx
);
530 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
531 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se_idx
) ||
532 nla_put_u8(msg
, NFC_ATTR_SE_TYPE
, se
->type
) ||
533 nla_put(msg
, NFC_ATTR_SE_AID
, evt_transaction
->aid_len
,
534 evt_transaction
->aid
) ||
535 nla_put(msg
, NFC_ATTR_SE_PARAMS
, evt_transaction
->params_len
,
536 evt_transaction
->params
))
537 goto nla_put_failure
;
539 /* evt_transaction is no more used */
540 devm_kfree(&dev
->dev
, evt_transaction
);
542 genlmsg_end(msg
, hdr
);
544 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
549 genlmsg_cancel(msg
, hdr
);
551 /* evt_transaction is no more used */
552 devm_kfree(&dev
->dev
, evt_transaction
);
557 int nfc_genl_se_connectivity(struct nfc_dev
*dev
, u8 se_idx
)
563 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
567 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
568 NFC_EVENT_SE_CONNECTIVITY
);
572 se
= nfc_find_se(dev
, se_idx
);
576 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
577 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se_idx
) ||
578 nla_put_u8(msg
, NFC_ATTR_SE_TYPE
, se
->type
))
579 goto nla_put_failure
;
581 genlmsg_end(msg
, hdr
);
583 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
588 genlmsg_cancel(msg
, hdr
);
594 static int nfc_genl_send_device(struct sk_buff
*msg
, struct nfc_dev
*dev
,
596 struct netlink_callback
*cb
,
601 hdr
= genlmsg_put(msg
, portid
, seq
, &nfc_genl_family
, flags
,
607 genl_dump_check_consistent(cb
, hdr
, &nfc_genl_family
);
609 if (nfc_genl_setup_device_added(dev
, msg
))
610 goto nla_put_failure
;
612 genlmsg_end(msg
, hdr
);
616 genlmsg_cancel(msg
, hdr
);
620 static int nfc_genl_dump_devices(struct sk_buff
*skb
,
621 struct netlink_callback
*cb
)
623 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
624 struct nfc_dev
*dev
= (struct nfc_dev
*) cb
->args
[1];
625 bool first_call
= false;
629 iter
= kmalloc(sizeof(struct class_dev_iter
), GFP_KERNEL
);
632 cb
->args
[0] = (long) iter
;
635 mutex_lock(&nfc_devlist_mutex
);
637 cb
->seq
= nfc_devlist_generation
;
640 nfc_device_iter_init(iter
);
641 dev
= nfc_device_iter_next(iter
);
647 rc
= nfc_genl_send_device(skb
, dev
, NETLINK_CB(cb
->skb
).portid
,
648 cb
->nlh
->nlmsg_seq
, cb
, NLM_F_MULTI
);
652 dev
= nfc_device_iter_next(iter
);
655 mutex_unlock(&nfc_devlist_mutex
);
657 cb
->args
[1] = (long) dev
;
662 static int nfc_genl_dump_devices_done(struct netlink_callback
*cb
)
664 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
666 nfc_device_iter_exit(iter
);
672 int nfc_genl_dep_link_up_event(struct nfc_dev
*dev
, u32 target_idx
,
673 u8 comm_mode
, u8 rf_mode
)
678 pr_debug("DEP link is up\n");
680 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
684 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0, NFC_CMD_DEP_LINK_UP
);
688 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
689 goto nla_put_failure
;
690 if (rf_mode
== NFC_RF_INITIATOR
&&
691 nla_put_u32(msg
, NFC_ATTR_TARGET_INDEX
, target_idx
))
692 goto nla_put_failure
;
693 if (nla_put_u8(msg
, NFC_ATTR_COMM_MODE
, comm_mode
) ||
694 nla_put_u8(msg
, NFC_ATTR_RF_MODE
, rf_mode
))
695 goto nla_put_failure
;
697 genlmsg_end(msg
, hdr
);
699 dev
->dep_link_up
= true;
701 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_ATOMIC
);
706 genlmsg_cancel(msg
, hdr
);
712 int nfc_genl_dep_link_down_event(struct nfc_dev
*dev
)
717 pr_debug("DEP link is down\n");
719 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
723 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
724 NFC_CMD_DEP_LINK_DOWN
);
728 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
729 goto nla_put_failure
;
731 genlmsg_end(msg
, hdr
);
733 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_ATOMIC
);
738 genlmsg_cancel(msg
, hdr
);
744 static int nfc_genl_get_device(struct sk_buff
*skb
, struct genl_info
*info
)
751 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
754 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
756 dev
= nfc_get_device(idx
);
760 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
766 rc
= nfc_genl_send_device(msg
, dev
, info
->snd_portid
, info
->snd_seq
,
773 return genlmsg_reply(msg
, info
);
782 static int nfc_genl_dev_up(struct sk_buff
*skb
, struct genl_info
*info
)
788 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
791 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
793 dev
= nfc_get_device(idx
);
797 rc
= nfc_dev_up(dev
);
803 static int nfc_genl_dev_down(struct sk_buff
*skb
, struct genl_info
*info
)
809 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
812 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
814 dev
= nfc_get_device(idx
);
818 rc
= nfc_dev_down(dev
);
824 static int nfc_genl_start_poll(struct sk_buff
*skb
, struct genl_info
*info
)
829 u32 im_protocols
= 0, tm_protocols
= 0;
831 pr_debug("Poll start\n");
833 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
834 ((!info
->attrs
[NFC_ATTR_IM_PROTOCOLS
] &&
835 !info
->attrs
[NFC_ATTR_PROTOCOLS
]) &&
836 !info
->attrs
[NFC_ATTR_TM_PROTOCOLS
]))
839 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
841 if (info
->attrs
[NFC_ATTR_TM_PROTOCOLS
])
842 tm_protocols
= nla_get_u32(info
->attrs
[NFC_ATTR_TM_PROTOCOLS
]);
844 if (info
->attrs
[NFC_ATTR_IM_PROTOCOLS
])
845 im_protocols
= nla_get_u32(info
->attrs
[NFC_ATTR_IM_PROTOCOLS
]);
846 else if (info
->attrs
[NFC_ATTR_PROTOCOLS
])
847 im_protocols
= nla_get_u32(info
->attrs
[NFC_ATTR_PROTOCOLS
]);
849 dev
= nfc_get_device(idx
);
853 mutex_lock(&dev
->genl_data
.genl_data_mutex
);
855 rc
= nfc_start_poll(dev
, im_protocols
, tm_protocols
);
857 dev
->genl_data
.poll_req_portid
= info
->snd_portid
;
859 mutex_unlock(&dev
->genl_data
.genl_data_mutex
);
865 static int nfc_genl_stop_poll(struct sk_buff
*skb
, struct genl_info
*info
)
871 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
874 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
876 dev
= nfc_get_device(idx
);
880 device_lock(&dev
->dev
);
883 device_unlock(&dev
->dev
);
887 device_unlock(&dev
->dev
);
889 mutex_lock(&dev
->genl_data
.genl_data_mutex
);
891 if (dev
->genl_data
.poll_req_portid
!= info
->snd_portid
) {
896 rc
= nfc_stop_poll(dev
);
897 dev
->genl_data
.poll_req_portid
= 0;
900 mutex_unlock(&dev
->genl_data
.genl_data_mutex
);
905 static int nfc_genl_activate_target(struct sk_buff
*skb
, struct genl_info
*info
)
908 u32 device_idx
, target_idx
, protocol
;
911 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
912 !info
->attrs
[NFC_ATTR_TARGET_INDEX
] ||
913 !info
->attrs
[NFC_ATTR_PROTOCOLS
])
916 device_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
918 dev
= nfc_get_device(device_idx
);
922 target_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_TARGET_INDEX
]);
923 protocol
= nla_get_u32(info
->attrs
[NFC_ATTR_PROTOCOLS
]);
925 nfc_deactivate_target(dev
, target_idx
, NFC_TARGET_MODE_SLEEP
);
926 rc
= nfc_activate_target(dev
, target_idx
, protocol
);
932 static int nfc_genl_dep_link_up(struct sk_buff
*skb
, struct genl_info
*info
)
939 pr_debug("DEP link up\n");
941 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
942 !info
->attrs
[NFC_ATTR_COMM_MODE
])
945 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
946 if (!info
->attrs
[NFC_ATTR_TARGET_INDEX
])
947 tgt_idx
= NFC_TARGET_IDX_ANY
;
949 tgt_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_TARGET_INDEX
]);
951 comm
= nla_get_u8(info
->attrs
[NFC_ATTR_COMM_MODE
]);
953 if (comm
!= NFC_COMM_ACTIVE
&& comm
!= NFC_COMM_PASSIVE
)
956 dev
= nfc_get_device(idx
);
960 rc
= nfc_dep_link_up(dev
, tgt_idx
, comm
);
967 static int nfc_genl_dep_link_down(struct sk_buff
*skb
, struct genl_info
*info
)
973 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
976 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
978 dev
= nfc_get_device(idx
);
982 rc
= nfc_dep_link_down(dev
);
988 static int nfc_genl_send_params(struct sk_buff
*msg
,
989 struct nfc_llcp_local
*local
,
994 hdr
= genlmsg_put(msg
, portid
, seq
, &nfc_genl_family
, 0,
995 NFC_CMD_LLC_GET_PARAMS
);
999 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, local
->dev
->idx
) ||
1000 nla_put_u8(msg
, NFC_ATTR_LLC_PARAM_LTO
, local
->lto
) ||
1001 nla_put_u8(msg
, NFC_ATTR_LLC_PARAM_RW
, local
->rw
) ||
1002 nla_put_u16(msg
, NFC_ATTR_LLC_PARAM_MIUX
, be16_to_cpu(local
->miux
)))
1003 goto nla_put_failure
;
1005 genlmsg_end(msg
, hdr
);
1010 genlmsg_cancel(msg
, hdr
);
1014 static int nfc_genl_llc_get_params(struct sk_buff
*skb
, struct genl_info
*info
)
1016 struct nfc_dev
*dev
;
1017 struct nfc_llcp_local
*local
;
1019 struct sk_buff
*msg
= NULL
;
1022 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
1025 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1027 dev
= nfc_get_device(idx
);
1031 device_lock(&dev
->dev
);
1033 local
= nfc_llcp_find_local(dev
);
1039 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1045 rc
= nfc_genl_send_params(msg
, local
, info
->snd_portid
, info
->snd_seq
);
1048 device_unlock(&dev
->dev
);
1050 nfc_put_device(dev
);
1059 return genlmsg_reply(msg
, info
);
1062 static int nfc_genl_llc_set_params(struct sk_buff
*skb
, struct genl_info
*info
)
1064 struct nfc_dev
*dev
;
1065 struct nfc_llcp_local
*local
;
1071 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1072 (!info
->attrs
[NFC_ATTR_LLC_PARAM_LTO
] &&
1073 !info
->attrs
[NFC_ATTR_LLC_PARAM_RW
] &&
1074 !info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
]))
1077 if (info
->attrs
[NFC_ATTR_LLC_PARAM_RW
]) {
1078 rw
= nla_get_u8(info
->attrs
[NFC_ATTR_LLC_PARAM_RW
]);
1080 if (rw
> LLCP_MAX_RW
)
1084 if (info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
]) {
1085 miux
= nla_get_u16(info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
]);
1087 if (miux
> LLCP_MAX_MIUX
)
1091 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1093 dev
= nfc_get_device(idx
);
1097 device_lock(&dev
->dev
);
1099 local
= nfc_llcp_find_local(dev
);
1101 nfc_put_device(dev
);
1106 if (info
->attrs
[NFC_ATTR_LLC_PARAM_LTO
]) {
1107 if (dev
->dep_link_up
) {
1112 local
->lto
= nla_get_u8(info
->attrs
[NFC_ATTR_LLC_PARAM_LTO
]);
1115 if (info
->attrs
[NFC_ATTR_LLC_PARAM_RW
])
1118 if (info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
])
1119 local
->miux
= cpu_to_be16(miux
);
1122 device_unlock(&dev
->dev
);
1124 nfc_put_device(dev
);
1129 static int nfc_genl_llc_sdreq(struct sk_buff
*skb
, struct genl_info
*info
)
1131 struct nfc_dev
*dev
;
1132 struct nfc_llcp_local
*local
;
1133 struct nlattr
*attr
, *sdp_attrs
[NFC_SDP_ATTR_MAX
+1];
1138 size_t uri_len
, tlvs_len
;
1139 struct hlist_head sdreq_list
;
1140 struct nfc_llcp_sdp_tlv
*sdreq
;
1142 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1143 !info
->attrs
[NFC_ATTR_LLC_SDP
])
1146 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1148 dev
= nfc_get_device(idx
);
1152 device_lock(&dev
->dev
);
1154 if (dev
->dep_link_up
== false) {
1159 local
= nfc_llcp_find_local(dev
);
1161 nfc_put_device(dev
);
1166 INIT_HLIST_HEAD(&sdreq_list
);
1170 nla_for_each_nested(attr
, info
->attrs
[NFC_ATTR_LLC_SDP
], rem
) {
1171 rc
= nla_parse_nested(sdp_attrs
, NFC_SDP_ATTR_MAX
, attr
,
1172 nfc_sdp_genl_policy
, info
->extack
);
1179 if (!sdp_attrs
[NFC_SDP_ATTR_URI
])
1182 uri_len
= nla_len(sdp_attrs
[NFC_SDP_ATTR_URI
]);
1186 uri
= nla_data(sdp_attrs
[NFC_SDP_ATTR_URI
]);
1187 if (uri
== NULL
|| *uri
== 0)
1190 tid
= local
->sdreq_next_tid
++;
1192 sdreq
= nfc_llcp_build_sdreq_tlv(tid
, uri
, uri_len
);
1193 if (sdreq
== NULL
) {
1198 tlvs_len
+= sdreq
->tlv_len
;
1200 hlist_add_head(&sdreq
->node
, &sdreq_list
);
1203 if (hlist_empty(&sdreq_list
)) {
1208 rc
= nfc_llcp_send_snl_sdreq(local
, &sdreq_list
, tlvs_len
);
1210 device_unlock(&dev
->dev
);
1212 nfc_put_device(dev
);
1217 static int nfc_genl_fw_download(struct sk_buff
*skb
, struct genl_info
*info
)
1219 struct nfc_dev
*dev
;
1222 char firmware_name
[NFC_FIRMWARE_NAME_MAXSIZE
+ 1];
1224 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
1227 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1229 dev
= nfc_get_device(idx
);
1233 nla_strlcpy(firmware_name
, info
->attrs
[NFC_ATTR_FIRMWARE_NAME
],
1234 sizeof(firmware_name
));
1236 rc
= nfc_fw_download(dev
, firmware_name
);
1238 nfc_put_device(dev
);
1242 int nfc_genl_fw_download_done(struct nfc_dev
*dev
, const char *firmware_name
,
1245 struct sk_buff
*msg
;
1248 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1252 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
1253 NFC_CMD_FW_DOWNLOAD
);
1257 if (nla_put_string(msg
, NFC_ATTR_FIRMWARE_NAME
, firmware_name
) ||
1258 nla_put_u32(msg
, NFC_ATTR_FIRMWARE_DOWNLOAD_STATUS
, result
) ||
1259 nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
1260 goto nla_put_failure
;
1262 genlmsg_end(msg
, hdr
);
1264 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
1269 genlmsg_cancel(msg
, hdr
);
1275 static int nfc_genl_enable_se(struct sk_buff
*skb
, struct genl_info
*info
)
1277 struct nfc_dev
*dev
;
1281 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1282 !info
->attrs
[NFC_ATTR_SE_INDEX
])
1285 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1286 se_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_SE_INDEX
]);
1288 dev
= nfc_get_device(idx
);
1292 rc
= nfc_enable_se(dev
, se_idx
);
1294 nfc_put_device(dev
);
1298 static int nfc_genl_disable_se(struct sk_buff
*skb
, struct genl_info
*info
)
1300 struct nfc_dev
*dev
;
1304 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1305 !info
->attrs
[NFC_ATTR_SE_INDEX
])
1308 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1309 se_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_SE_INDEX
]);
1311 dev
= nfc_get_device(idx
);
1315 rc
= nfc_disable_se(dev
, se_idx
);
1317 nfc_put_device(dev
);
1321 static int nfc_genl_send_se(struct sk_buff
*msg
, struct nfc_dev
*dev
,
1322 u32 portid
, u32 seq
,
1323 struct netlink_callback
*cb
,
1327 struct nfc_se
*se
, *n
;
1329 list_for_each_entry_safe(se
, n
, &dev
->secure_elements
, list
) {
1330 hdr
= genlmsg_put(msg
, portid
, seq
, &nfc_genl_family
, flags
,
1333 goto nla_put_failure
;
1336 genl_dump_check_consistent(cb
, hdr
, &nfc_genl_family
);
1338 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
1339 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se
->idx
) ||
1340 nla_put_u8(msg
, NFC_ATTR_SE_TYPE
, se
->type
))
1341 goto nla_put_failure
;
1343 genlmsg_end(msg
, hdr
);
1349 genlmsg_cancel(msg
, hdr
);
1353 static int nfc_genl_dump_ses(struct sk_buff
*skb
,
1354 struct netlink_callback
*cb
)
1356 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
1357 struct nfc_dev
*dev
= (struct nfc_dev
*) cb
->args
[1];
1358 bool first_call
= false;
1362 iter
= kmalloc(sizeof(struct class_dev_iter
), GFP_KERNEL
);
1365 cb
->args
[0] = (long) iter
;
1368 mutex_lock(&nfc_devlist_mutex
);
1370 cb
->seq
= nfc_devlist_generation
;
1373 nfc_device_iter_init(iter
);
1374 dev
= nfc_device_iter_next(iter
);
1380 rc
= nfc_genl_send_se(skb
, dev
, NETLINK_CB(cb
->skb
).portid
,
1381 cb
->nlh
->nlmsg_seq
, cb
, NLM_F_MULTI
);
1385 dev
= nfc_device_iter_next(iter
);
1388 mutex_unlock(&nfc_devlist_mutex
);
1390 cb
->args
[1] = (long) dev
;
1395 static int nfc_genl_dump_ses_done(struct netlink_callback
*cb
)
1397 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
1399 nfc_device_iter_exit(iter
);
1405 static int nfc_se_io(struct nfc_dev
*dev
, u32 se_idx
,
1406 u8
*apdu
, size_t apdu_length
,
1407 se_io_cb_t cb
, void *cb_context
)
1412 pr_debug("%s se index %d\n", dev_name(&dev
->dev
), se_idx
);
1414 device_lock(&dev
->dev
);
1416 if (!device_is_registered(&dev
->dev
)) {
1426 if (!dev
->ops
->se_io
) {
1431 se
= nfc_find_se(dev
, se_idx
);
1437 if (se
->state
!= NFC_SE_ENABLED
) {
1442 rc
= dev
->ops
->se_io(dev
, se_idx
, apdu
,
1443 apdu_length
, cb
, cb_context
);
1446 device_unlock(&dev
->dev
);
1455 static void se_io_cb(void *context
, u8
*apdu
, size_t apdu_len
, int err
)
1457 struct se_io_ctx
*ctx
= context
;
1458 struct sk_buff
*msg
;
1461 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1467 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
1472 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, ctx
->dev_idx
) ||
1473 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, ctx
->se_idx
) ||
1474 nla_put(msg
, NFC_ATTR_SE_APDU
, apdu_len
, apdu
))
1475 goto nla_put_failure
;
1477 genlmsg_end(msg
, hdr
);
1479 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
1486 genlmsg_cancel(msg
, hdr
);
1494 static int nfc_genl_se_io(struct sk_buff
*skb
, struct genl_info
*info
)
1496 struct nfc_dev
*dev
;
1497 struct se_io_ctx
*ctx
;
1498 u32 dev_idx
, se_idx
;
1502 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1503 !info
->attrs
[NFC_ATTR_SE_INDEX
] ||
1504 !info
->attrs
[NFC_ATTR_SE_APDU
])
1507 dev_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1508 se_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_SE_INDEX
]);
1510 dev
= nfc_get_device(dev_idx
);
1514 if (!dev
->ops
|| !dev
->ops
->se_io
)
1517 apdu_len
= nla_len(info
->attrs
[NFC_ATTR_SE_APDU
]);
1521 apdu
= nla_data(info
->attrs
[NFC_ATTR_SE_APDU
]);
1525 ctx
= kzalloc(sizeof(struct se_io_ctx
), GFP_KERNEL
);
1529 ctx
->dev_idx
= dev_idx
;
1530 ctx
->se_idx
= se_idx
;
1532 return nfc_se_io(dev
, se_idx
, apdu
, apdu_len
, se_io_cb
, ctx
);
1535 static int nfc_genl_vendor_cmd(struct sk_buff
*skb
,
1536 struct genl_info
*info
)
1538 struct nfc_dev
*dev
;
1539 struct nfc_vendor_cmd
*cmd
;
1540 u32 dev_idx
, vid
, subcmd
;
1545 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1546 !info
->attrs
[NFC_ATTR_VENDOR_ID
] ||
1547 !info
->attrs
[NFC_ATTR_VENDOR_SUBCMD
])
1550 dev_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1551 vid
= nla_get_u32(info
->attrs
[NFC_ATTR_VENDOR_ID
]);
1552 subcmd
= nla_get_u32(info
->attrs
[NFC_ATTR_VENDOR_SUBCMD
]);
1554 dev
= nfc_get_device(dev_idx
);
1555 if (!dev
|| !dev
->vendor_cmds
|| !dev
->n_vendor_cmds
)
1558 if (info
->attrs
[NFC_ATTR_VENDOR_DATA
]) {
1559 data
= nla_data(info
->attrs
[NFC_ATTR_VENDOR_DATA
]);
1560 data_len
= nla_len(info
->attrs
[NFC_ATTR_VENDOR_DATA
]);
1568 for (i
= 0; i
< dev
->n_vendor_cmds
; i
++) {
1569 cmd
= &dev
->vendor_cmds
[i
];
1571 if (cmd
->vendor_id
!= vid
|| cmd
->subcmd
!= subcmd
)
1574 dev
->cur_cmd_info
= info
;
1575 err
= cmd
->doit(dev
, data
, data_len
);
1576 dev
->cur_cmd_info
= NULL
;
1583 /* message building helper */
1584 static inline void *nfc_hdr_put(struct sk_buff
*skb
, u32 portid
, u32 seq
,
1587 /* since there is no private header just add the generic one */
1588 return genlmsg_put(skb
, portid
, seq
, &nfc_genl_family
, flags
, cmd
);
1591 static struct sk_buff
*
1592 __nfc_alloc_vendor_cmd_skb(struct nfc_dev
*dev
, int approxlen
,
1593 u32 portid
, u32 seq
,
1594 enum nfc_attrs attr
,
1595 u32 oui
, u32 subcmd
, gfp_t gfp
)
1597 struct sk_buff
*skb
;
1600 skb
= nlmsg_new(approxlen
+ 100, gfp
);
1604 hdr
= nfc_hdr_put(skb
, portid
, seq
, 0, NFC_CMD_VENDOR
);
1610 if (nla_put_u32(skb
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
1611 goto nla_put_failure
;
1612 if (nla_put_u32(skb
, NFC_ATTR_VENDOR_ID
, oui
))
1613 goto nla_put_failure
;
1614 if (nla_put_u32(skb
, NFC_ATTR_VENDOR_SUBCMD
, subcmd
))
1615 goto nla_put_failure
;
1617 ((void **)skb
->cb
)[0] = dev
;
1618 ((void **)skb
->cb
)[1] = hdr
;
1627 struct sk_buff
*__nfc_alloc_vendor_cmd_reply_skb(struct nfc_dev
*dev
,
1628 enum nfc_attrs attr
,
1629 u32 oui
, u32 subcmd
,
1632 if (WARN_ON(!dev
->cur_cmd_info
))
1635 return __nfc_alloc_vendor_cmd_skb(dev
, approxlen
,
1636 dev
->cur_cmd_info
->snd_portid
,
1637 dev
->cur_cmd_info
->snd_seq
, attr
,
1638 oui
, subcmd
, GFP_KERNEL
);
1640 EXPORT_SYMBOL(__nfc_alloc_vendor_cmd_reply_skb
);
1642 int nfc_vendor_cmd_reply(struct sk_buff
*skb
)
1644 struct nfc_dev
*dev
= ((void **)skb
->cb
)[0];
1645 void *hdr
= ((void **)skb
->cb
)[1];
1647 /* clear CB data for netlink core to own from now on */
1648 memset(skb
->cb
, 0, sizeof(skb
->cb
));
1650 if (WARN_ON(!dev
->cur_cmd_info
)) {
1655 genlmsg_end(skb
, hdr
);
1656 return genlmsg_reply(skb
, dev
->cur_cmd_info
);
1658 EXPORT_SYMBOL(nfc_vendor_cmd_reply
);
1660 static const struct genl_ops nfc_genl_ops
[] = {
1662 .cmd
= NFC_CMD_GET_DEVICE
,
1663 .doit
= nfc_genl_get_device
,
1664 .dumpit
= nfc_genl_dump_devices
,
1665 .done
= nfc_genl_dump_devices_done
,
1666 .policy
= nfc_genl_policy
,
1669 .cmd
= NFC_CMD_DEV_UP
,
1670 .doit
= nfc_genl_dev_up
,
1671 .policy
= nfc_genl_policy
,
1674 .cmd
= NFC_CMD_DEV_DOWN
,
1675 .doit
= nfc_genl_dev_down
,
1676 .policy
= nfc_genl_policy
,
1679 .cmd
= NFC_CMD_START_POLL
,
1680 .doit
= nfc_genl_start_poll
,
1681 .policy
= nfc_genl_policy
,
1684 .cmd
= NFC_CMD_STOP_POLL
,
1685 .doit
= nfc_genl_stop_poll
,
1686 .policy
= nfc_genl_policy
,
1689 .cmd
= NFC_CMD_DEP_LINK_UP
,
1690 .doit
= nfc_genl_dep_link_up
,
1691 .policy
= nfc_genl_policy
,
1694 .cmd
= NFC_CMD_DEP_LINK_DOWN
,
1695 .doit
= nfc_genl_dep_link_down
,
1696 .policy
= nfc_genl_policy
,
1699 .cmd
= NFC_CMD_GET_TARGET
,
1700 .dumpit
= nfc_genl_dump_targets
,
1701 .done
= nfc_genl_dump_targets_done
,
1702 .policy
= nfc_genl_policy
,
1705 .cmd
= NFC_CMD_LLC_GET_PARAMS
,
1706 .doit
= nfc_genl_llc_get_params
,
1707 .policy
= nfc_genl_policy
,
1710 .cmd
= NFC_CMD_LLC_SET_PARAMS
,
1711 .doit
= nfc_genl_llc_set_params
,
1712 .policy
= nfc_genl_policy
,
1715 .cmd
= NFC_CMD_LLC_SDREQ
,
1716 .doit
= nfc_genl_llc_sdreq
,
1717 .policy
= nfc_genl_policy
,
1720 .cmd
= NFC_CMD_FW_DOWNLOAD
,
1721 .doit
= nfc_genl_fw_download
,
1722 .policy
= nfc_genl_policy
,
1725 .cmd
= NFC_CMD_ENABLE_SE
,
1726 .doit
= nfc_genl_enable_se
,
1727 .policy
= nfc_genl_policy
,
1730 .cmd
= NFC_CMD_DISABLE_SE
,
1731 .doit
= nfc_genl_disable_se
,
1732 .policy
= nfc_genl_policy
,
1735 .cmd
= NFC_CMD_GET_SE
,
1736 .dumpit
= nfc_genl_dump_ses
,
1737 .done
= nfc_genl_dump_ses_done
,
1738 .policy
= nfc_genl_policy
,
1741 .cmd
= NFC_CMD_SE_IO
,
1742 .doit
= nfc_genl_se_io
,
1743 .policy
= nfc_genl_policy
,
1746 .cmd
= NFC_CMD_ACTIVATE_TARGET
,
1747 .doit
= nfc_genl_activate_target
,
1748 .policy
= nfc_genl_policy
,
1751 .cmd
= NFC_CMD_VENDOR
,
1752 .doit
= nfc_genl_vendor_cmd
,
1753 .policy
= nfc_genl_policy
,
1757 static struct genl_family nfc_genl_family __ro_after_init
= {
1759 .name
= NFC_GENL_NAME
,
1760 .version
= NFC_GENL_VERSION
,
1761 .maxattr
= NFC_ATTR_MAX
,
1762 .module
= THIS_MODULE
,
1763 .ops
= nfc_genl_ops
,
1764 .n_ops
= ARRAY_SIZE(nfc_genl_ops
),
1765 .mcgrps
= nfc_genl_mcgrps
,
1766 .n_mcgrps
= ARRAY_SIZE(nfc_genl_mcgrps
),
1770 struct urelease_work
{
1771 struct work_struct w
;
1775 static void nfc_urelease_event_work(struct work_struct
*work
)
1777 struct urelease_work
*w
= container_of(work
, struct urelease_work
, w
);
1778 struct class_dev_iter iter
;
1779 struct nfc_dev
*dev
;
1781 pr_debug("portid %d\n", w
->portid
);
1783 mutex_lock(&nfc_devlist_mutex
);
1785 nfc_device_iter_init(&iter
);
1786 dev
= nfc_device_iter_next(&iter
);
1789 mutex_lock(&dev
->genl_data
.genl_data_mutex
);
1791 if (dev
->genl_data
.poll_req_portid
== w
->portid
) {
1793 dev
->genl_data
.poll_req_portid
= 0;
1796 mutex_unlock(&dev
->genl_data
.genl_data_mutex
);
1798 dev
= nfc_device_iter_next(&iter
);
1801 nfc_device_iter_exit(&iter
);
1803 mutex_unlock(&nfc_devlist_mutex
);
1808 static int nfc_genl_rcv_nl_event(struct notifier_block
*this,
1809 unsigned long event
, void *ptr
)
1811 struct netlink_notify
*n
= ptr
;
1812 struct urelease_work
*w
;
1814 if (event
!= NETLINK_URELEASE
|| n
->protocol
!= NETLINK_GENERIC
)
1817 pr_debug("NETLINK_URELEASE event from id %d\n", n
->portid
);
1819 w
= kmalloc(sizeof(*w
), GFP_ATOMIC
);
1821 INIT_WORK((struct work_struct
*) w
, nfc_urelease_event_work
);
1822 w
->portid
= n
->portid
;
1823 schedule_work((struct work_struct
*) w
);
1830 void nfc_genl_data_init(struct nfc_genl_data
*genl_data
)
1832 genl_data
->poll_req_portid
= 0;
1833 mutex_init(&genl_data
->genl_data_mutex
);
1836 void nfc_genl_data_exit(struct nfc_genl_data
*genl_data
)
1838 mutex_destroy(&genl_data
->genl_data_mutex
);
1841 static struct notifier_block nl_notifier
= {
1842 .notifier_call
= nfc_genl_rcv_nl_event
,
1846 * nfc_genl_init() - Initialize netlink interface
1848 * This initialization function registers the nfc netlink family.
1850 int __init
nfc_genl_init(void)
1854 rc
= genl_register_family(&nfc_genl_family
);
1858 netlink_register_notifier(&nl_notifier
);
1864 * nfc_genl_exit() - Deinitialize netlink interface
1866 * This exit function unregisters the nfc netlink family.
1868 void nfc_genl_exit(void)
1870 netlink_unregister_notifier(&nl_notifier
);
1871 genl_unregister_family(&nfc_genl_family
);