1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2011 Instituto Nokia de Tecnologia
6 * Lauro Ramos Venancio <lauro.venancio@openbossa.org>
7 * Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
9 * Vendor commands implementation based on net/wireless/nl80211.c
12 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
13 * Copyright 2013-2014 Intel Mobile Communications GmbH
16 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
18 #include <net/genetlink.h>
19 #include <linux/nfc.h>
20 #include <linux/slab.h>
25 static const struct genl_multicast_group nfc_genl_mcgrps
[] = {
26 { .name
= NFC_GENL_MCAST_EVENT_NAME
, },
29 static struct genl_family nfc_genl_family
;
30 static const struct nla_policy nfc_genl_policy
[NFC_ATTR_MAX
+ 1] = {
31 [NFC_ATTR_DEVICE_INDEX
] = { .type
= NLA_U32
},
32 [NFC_ATTR_DEVICE_NAME
] = { .type
= NLA_STRING
,
33 .len
= NFC_DEVICE_NAME_MAXSIZE
},
34 [NFC_ATTR_PROTOCOLS
] = { .type
= NLA_U32
},
35 [NFC_ATTR_COMM_MODE
] = { .type
= NLA_U8
},
36 [NFC_ATTR_RF_MODE
] = { .type
= NLA_U8
},
37 [NFC_ATTR_DEVICE_POWERED
] = { .type
= NLA_U8
},
38 [NFC_ATTR_IM_PROTOCOLS
] = { .type
= NLA_U32
},
39 [NFC_ATTR_TM_PROTOCOLS
] = { .type
= NLA_U32
},
40 [NFC_ATTR_LLC_PARAM_LTO
] = { .type
= NLA_U8
},
41 [NFC_ATTR_LLC_PARAM_RW
] = { .type
= NLA_U8
},
42 [NFC_ATTR_LLC_PARAM_MIUX
] = { .type
= NLA_U16
},
43 [NFC_ATTR_LLC_SDP
] = { .type
= NLA_NESTED
},
44 [NFC_ATTR_FIRMWARE_NAME
] = { .type
= NLA_STRING
,
45 .len
= NFC_FIRMWARE_NAME_MAXSIZE
},
46 [NFC_ATTR_SE_APDU
] = { .type
= NLA_BINARY
},
47 [NFC_ATTR_VENDOR_DATA
] = { .type
= NLA_BINARY
},
51 static const struct nla_policy nfc_sdp_genl_policy
[NFC_SDP_ATTR_MAX
+ 1] = {
52 [NFC_SDP_ATTR_URI
] = { .type
= NLA_STRING
,
54 [NFC_SDP_ATTR_SAP
] = { .type
= NLA_U8
},
57 static int nfc_genl_send_target(struct sk_buff
*msg
, struct nfc_target
*target
,
58 struct netlink_callback
*cb
, int flags
)
62 hdr
= genlmsg_put(msg
, NETLINK_CB(cb
->skb
).portid
, cb
->nlh
->nlmsg_seq
,
63 &nfc_genl_family
, flags
, NFC_CMD_GET_TARGET
);
67 genl_dump_check_consistent(cb
, hdr
);
69 if (nla_put_u32(msg
, NFC_ATTR_TARGET_INDEX
, target
->idx
) ||
70 nla_put_u32(msg
, NFC_ATTR_PROTOCOLS
, target
->supported_protocols
) ||
71 nla_put_u16(msg
, NFC_ATTR_TARGET_SENS_RES
, target
->sens_res
) ||
72 nla_put_u8(msg
, NFC_ATTR_TARGET_SEL_RES
, target
->sel_res
))
74 if (target
->nfcid1_len
> 0 &&
75 nla_put(msg
, NFC_ATTR_TARGET_NFCID1
, target
->nfcid1_len
,
78 if (target
->sensb_res_len
> 0 &&
79 nla_put(msg
, NFC_ATTR_TARGET_SENSB_RES
, target
->sensb_res_len
,
82 if (target
->sensf_res_len
> 0 &&
83 nla_put(msg
, NFC_ATTR_TARGET_SENSF_RES
, target
->sensf_res_len
,
87 if (target
->is_iso15693
) {
88 if (nla_put_u8(msg
, NFC_ATTR_TARGET_ISO15693_DSFID
,
89 target
->iso15693_dsfid
) ||
90 nla_put(msg
, NFC_ATTR_TARGET_ISO15693_UID
,
91 sizeof(target
->iso15693_uid
), target
->iso15693_uid
))
95 genlmsg_end(msg
, hdr
);
99 genlmsg_cancel(msg
, hdr
);
103 static struct nfc_dev
*__get_device_from_cb(struct netlink_callback
*cb
)
105 struct nlattr
**attrbuf
= genl_family_attrbuf(&nfc_genl_family
);
110 rc
= nlmsg_parse_deprecated(cb
->nlh
,
111 GENL_HDRLEN
+ nfc_genl_family
.hdrsize
,
112 attrbuf
, nfc_genl_family
.maxattr
,
113 nfc_genl_policy
, NULL
);
117 if (!attrbuf
[NFC_ATTR_DEVICE_INDEX
])
118 return ERR_PTR(-EINVAL
);
120 idx
= nla_get_u32(attrbuf
[NFC_ATTR_DEVICE_INDEX
]);
122 dev
= nfc_get_device(idx
);
124 return ERR_PTR(-ENODEV
);
129 static int nfc_genl_dump_targets(struct sk_buff
*skb
,
130 struct netlink_callback
*cb
)
133 struct nfc_dev
*dev
= (struct nfc_dev
*) cb
->args
[1];
137 dev
= __get_device_from_cb(cb
);
141 cb
->args
[1] = (long) dev
;
144 device_lock(&dev
->dev
);
146 cb
->seq
= dev
->targets_generation
;
148 while (i
< dev
->n_targets
) {
149 rc
= nfc_genl_send_target(skb
, &dev
->targets
[i
], cb
,
157 device_unlock(&dev
->dev
);
164 static int nfc_genl_dump_targets_done(struct netlink_callback
*cb
)
166 struct nfc_dev
*dev
= (struct nfc_dev
*) cb
->args
[1];
174 int nfc_genl_targets_found(struct nfc_dev
*dev
)
179 dev
->genl_data
.poll_req_portid
= 0;
181 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
185 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
186 NFC_EVENT_TARGETS_FOUND
);
190 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
191 goto nla_put_failure
;
193 genlmsg_end(msg
, hdr
);
195 return genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_ATOMIC
);
203 int nfc_genl_target_lost(struct nfc_dev
*dev
, u32 target_idx
)
208 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
212 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
213 NFC_EVENT_TARGET_LOST
);
217 if (nla_put_string(msg
, NFC_ATTR_DEVICE_NAME
, nfc_device_name(dev
)) ||
218 nla_put_u32(msg
, NFC_ATTR_TARGET_INDEX
, target_idx
))
219 goto nla_put_failure
;
221 genlmsg_end(msg
, hdr
);
223 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
233 int nfc_genl_tm_activated(struct nfc_dev
*dev
, u32 protocol
)
238 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
242 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
243 NFC_EVENT_TM_ACTIVATED
);
247 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
248 goto nla_put_failure
;
249 if (nla_put_u32(msg
, NFC_ATTR_TM_PROTOCOLS
, protocol
))
250 goto nla_put_failure
;
252 genlmsg_end(msg
, hdr
);
254 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
264 int nfc_genl_tm_deactivated(struct nfc_dev
*dev
)
269 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
273 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
274 NFC_EVENT_TM_DEACTIVATED
);
278 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
279 goto nla_put_failure
;
281 genlmsg_end(msg
, hdr
);
283 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
293 static int nfc_genl_setup_device_added(struct nfc_dev
*dev
, struct sk_buff
*msg
)
295 if (nla_put_string(msg
, NFC_ATTR_DEVICE_NAME
, nfc_device_name(dev
)) ||
296 nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
297 nla_put_u32(msg
, NFC_ATTR_PROTOCOLS
, dev
->supported_protocols
) ||
298 nla_put_u8(msg
, NFC_ATTR_DEVICE_POWERED
, dev
->dev_up
) ||
299 nla_put_u8(msg
, NFC_ATTR_RF_MODE
, dev
->rf_mode
))
304 int nfc_genl_device_added(struct nfc_dev
*dev
)
309 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
313 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
314 NFC_EVENT_DEVICE_ADDED
);
318 if (nfc_genl_setup_device_added(dev
, msg
))
319 goto nla_put_failure
;
321 genlmsg_end(msg
, hdr
);
323 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
333 int nfc_genl_device_removed(struct nfc_dev
*dev
)
338 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
342 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
343 NFC_EVENT_DEVICE_REMOVED
);
347 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
348 goto nla_put_failure
;
350 genlmsg_end(msg
, hdr
);
352 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
362 int nfc_genl_llc_send_sdres(struct nfc_dev
*dev
, struct hlist_head
*sdres_list
)
365 struct nlattr
*sdp_attr
, *uri_attr
;
366 struct nfc_llcp_sdp_tlv
*sdres
;
367 struct hlist_node
*n
;
372 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
376 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
377 NFC_EVENT_LLC_SDRES
);
381 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
382 goto nla_put_failure
;
384 sdp_attr
= nla_nest_start_noflag(msg
, NFC_ATTR_LLC_SDP
);
385 if (sdp_attr
== NULL
) {
387 goto nla_put_failure
;
391 hlist_for_each_entry_safe(sdres
, n
, sdres_list
, node
) {
392 pr_debug("uri: %s, sap: %d\n", sdres
->uri
, sdres
->sap
);
394 uri_attr
= nla_nest_start_noflag(msg
, i
++);
395 if (uri_attr
== NULL
) {
397 goto nla_put_failure
;
400 if (nla_put_u8(msg
, NFC_SDP_ATTR_SAP
, sdres
->sap
))
401 goto nla_put_failure
;
403 if (nla_put_string(msg
, NFC_SDP_ATTR_URI
, sdres
->uri
))
404 goto nla_put_failure
;
406 nla_nest_end(msg
, uri_attr
);
408 hlist_del(&sdres
->node
);
410 nfc_llcp_free_sdp_tlv(sdres
);
413 nla_nest_end(msg
, sdp_attr
);
415 genlmsg_end(msg
, hdr
);
417 return genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_ATOMIC
);
423 nfc_llcp_free_sdp_tlv_list(sdres_list
);
428 int nfc_genl_se_added(struct nfc_dev
*dev
, u32 se_idx
, u16 type
)
433 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
437 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
442 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
443 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se_idx
) ||
444 nla_put_u8(msg
, NFC_ATTR_SE_TYPE
, type
))
445 goto nla_put_failure
;
447 genlmsg_end(msg
, hdr
);
449 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
459 int nfc_genl_se_removed(struct nfc_dev
*dev
, u32 se_idx
)
464 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
468 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
469 NFC_EVENT_SE_REMOVED
);
473 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
474 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se_idx
))
475 goto nla_put_failure
;
477 genlmsg_end(msg
, hdr
);
479 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
489 int nfc_genl_se_transaction(struct nfc_dev
*dev
, u8 se_idx
,
490 struct nfc_evt_transaction
*evt_transaction
)
496 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
500 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
501 NFC_EVENT_SE_TRANSACTION
);
505 se
= nfc_find_se(dev
, se_idx
);
509 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
510 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se_idx
) ||
511 nla_put_u8(msg
, NFC_ATTR_SE_TYPE
, se
->type
) ||
512 nla_put(msg
, NFC_ATTR_SE_AID
, evt_transaction
->aid_len
,
513 evt_transaction
->aid
) ||
514 nla_put(msg
, NFC_ATTR_SE_PARAMS
, evt_transaction
->params_len
,
515 evt_transaction
->params
))
516 goto nla_put_failure
;
518 /* evt_transaction is no more used */
519 devm_kfree(&dev
->dev
, evt_transaction
);
521 genlmsg_end(msg
, hdr
);
523 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
529 /* evt_transaction is no more used */
530 devm_kfree(&dev
->dev
, evt_transaction
);
535 int nfc_genl_se_connectivity(struct nfc_dev
*dev
, u8 se_idx
)
541 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
545 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
546 NFC_EVENT_SE_CONNECTIVITY
);
550 se
= nfc_find_se(dev
, se_idx
);
554 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
555 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se_idx
) ||
556 nla_put_u8(msg
, NFC_ATTR_SE_TYPE
, se
->type
))
557 goto nla_put_failure
;
559 genlmsg_end(msg
, hdr
);
561 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
571 static int nfc_genl_send_device(struct sk_buff
*msg
, struct nfc_dev
*dev
,
573 struct netlink_callback
*cb
,
578 hdr
= genlmsg_put(msg
, portid
, seq
, &nfc_genl_family
, flags
,
584 genl_dump_check_consistent(cb
, hdr
);
586 if (nfc_genl_setup_device_added(dev
, msg
))
587 goto nla_put_failure
;
589 genlmsg_end(msg
, hdr
);
593 genlmsg_cancel(msg
, hdr
);
597 static int nfc_genl_dump_devices(struct sk_buff
*skb
,
598 struct netlink_callback
*cb
)
600 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
601 struct nfc_dev
*dev
= (struct nfc_dev
*) cb
->args
[1];
602 bool first_call
= false;
606 iter
= kmalloc(sizeof(struct class_dev_iter
), GFP_KERNEL
);
609 cb
->args
[0] = (long) iter
;
612 mutex_lock(&nfc_devlist_mutex
);
614 cb
->seq
= nfc_devlist_generation
;
617 nfc_device_iter_init(iter
);
618 dev
= nfc_device_iter_next(iter
);
624 rc
= nfc_genl_send_device(skb
, dev
, NETLINK_CB(cb
->skb
).portid
,
625 cb
->nlh
->nlmsg_seq
, cb
, NLM_F_MULTI
);
629 dev
= nfc_device_iter_next(iter
);
632 mutex_unlock(&nfc_devlist_mutex
);
634 cb
->args
[1] = (long) dev
;
639 static int nfc_genl_dump_devices_done(struct netlink_callback
*cb
)
641 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
643 nfc_device_iter_exit(iter
);
649 int nfc_genl_dep_link_up_event(struct nfc_dev
*dev
, u32 target_idx
,
650 u8 comm_mode
, u8 rf_mode
)
655 pr_debug("DEP link is up\n");
657 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
661 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0, NFC_CMD_DEP_LINK_UP
);
665 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
666 goto nla_put_failure
;
667 if (rf_mode
== NFC_RF_INITIATOR
&&
668 nla_put_u32(msg
, NFC_ATTR_TARGET_INDEX
, target_idx
))
669 goto nla_put_failure
;
670 if (nla_put_u8(msg
, NFC_ATTR_COMM_MODE
, comm_mode
) ||
671 nla_put_u8(msg
, NFC_ATTR_RF_MODE
, rf_mode
))
672 goto nla_put_failure
;
674 genlmsg_end(msg
, hdr
);
676 dev
->dep_link_up
= true;
678 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_ATOMIC
);
688 int nfc_genl_dep_link_down_event(struct nfc_dev
*dev
)
693 pr_debug("DEP link is down\n");
695 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
699 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
700 NFC_CMD_DEP_LINK_DOWN
);
704 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
705 goto nla_put_failure
;
707 genlmsg_end(msg
, hdr
);
709 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_ATOMIC
);
719 static int nfc_genl_get_device(struct sk_buff
*skb
, struct genl_info
*info
)
726 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
729 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
731 dev
= nfc_get_device(idx
);
735 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
741 rc
= nfc_genl_send_device(msg
, dev
, info
->snd_portid
, info
->snd_seq
,
748 return genlmsg_reply(msg
, info
);
757 static int nfc_genl_dev_up(struct sk_buff
*skb
, struct genl_info
*info
)
763 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
766 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
768 dev
= nfc_get_device(idx
);
772 rc
= nfc_dev_up(dev
);
778 static int nfc_genl_dev_down(struct sk_buff
*skb
, struct genl_info
*info
)
784 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
787 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
789 dev
= nfc_get_device(idx
);
793 rc
= nfc_dev_down(dev
);
799 static int nfc_genl_start_poll(struct sk_buff
*skb
, struct genl_info
*info
)
804 u32 im_protocols
= 0, tm_protocols
= 0;
806 pr_debug("Poll start\n");
808 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
809 ((!info
->attrs
[NFC_ATTR_IM_PROTOCOLS
] &&
810 !info
->attrs
[NFC_ATTR_PROTOCOLS
]) &&
811 !info
->attrs
[NFC_ATTR_TM_PROTOCOLS
]))
814 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
816 if (info
->attrs
[NFC_ATTR_TM_PROTOCOLS
])
817 tm_protocols
= nla_get_u32(info
->attrs
[NFC_ATTR_TM_PROTOCOLS
]);
819 if (info
->attrs
[NFC_ATTR_IM_PROTOCOLS
])
820 im_protocols
= nla_get_u32(info
->attrs
[NFC_ATTR_IM_PROTOCOLS
]);
821 else if (info
->attrs
[NFC_ATTR_PROTOCOLS
])
822 im_protocols
= nla_get_u32(info
->attrs
[NFC_ATTR_PROTOCOLS
]);
824 dev
= nfc_get_device(idx
);
828 mutex_lock(&dev
->genl_data
.genl_data_mutex
);
830 rc
= nfc_start_poll(dev
, im_protocols
, tm_protocols
);
832 dev
->genl_data
.poll_req_portid
= info
->snd_portid
;
834 mutex_unlock(&dev
->genl_data
.genl_data_mutex
);
840 static int nfc_genl_stop_poll(struct sk_buff
*skb
, struct genl_info
*info
)
846 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
849 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
851 dev
= nfc_get_device(idx
);
855 device_lock(&dev
->dev
);
858 device_unlock(&dev
->dev
);
862 device_unlock(&dev
->dev
);
864 mutex_lock(&dev
->genl_data
.genl_data_mutex
);
866 if (dev
->genl_data
.poll_req_portid
!= info
->snd_portid
) {
871 rc
= nfc_stop_poll(dev
);
872 dev
->genl_data
.poll_req_portid
= 0;
875 mutex_unlock(&dev
->genl_data
.genl_data_mutex
);
880 static int nfc_genl_activate_target(struct sk_buff
*skb
, struct genl_info
*info
)
883 u32 device_idx
, target_idx
, protocol
;
886 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
887 !info
->attrs
[NFC_ATTR_TARGET_INDEX
] ||
888 !info
->attrs
[NFC_ATTR_PROTOCOLS
])
891 device_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
893 dev
= nfc_get_device(device_idx
);
897 target_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_TARGET_INDEX
]);
898 protocol
= nla_get_u32(info
->attrs
[NFC_ATTR_PROTOCOLS
]);
900 nfc_deactivate_target(dev
, target_idx
, NFC_TARGET_MODE_SLEEP
);
901 rc
= nfc_activate_target(dev
, target_idx
, protocol
);
907 static int nfc_genl_deactivate_target(struct sk_buff
*skb
,
908 struct genl_info
*info
)
911 u32 device_idx
, target_idx
;
914 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
915 !info
->attrs
[NFC_ATTR_TARGET_INDEX
])
918 device_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
920 dev
= nfc_get_device(device_idx
);
924 target_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_TARGET_INDEX
]);
926 rc
= nfc_deactivate_target(dev
, target_idx
, NFC_TARGET_MODE_SLEEP
);
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
);
1009 genlmsg_cancel(msg
, hdr
);
1013 static int nfc_genl_llc_get_params(struct sk_buff
*skb
, struct genl_info
*info
)
1015 struct nfc_dev
*dev
;
1016 struct nfc_llcp_local
*local
;
1018 struct sk_buff
*msg
= NULL
;
1021 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
1024 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1026 dev
= nfc_get_device(idx
);
1030 device_lock(&dev
->dev
);
1032 local
= nfc_llcp_find_local(dev
);
1038 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1044 rc
= nfc_genl_send_params(msg
, local
, info
->snd_portid
, info
->snd_seq
);
1047 device_unlock(&dev
->dev
);
1049 nfc_put_device(dev
);
1058 return genlmsg_reply(msg
, info
);
1061 static int nfc_genl_llc_set_params(struct sk_buff
*skb
, struct genl_info
*info
)
1063 struct nfc_dev
*dev
;
1064 struct nfc_llcp_local
*local
;
1070 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1071 (!info
->attrs
[NFC_ATTR_LLC_PARAM_LTO
] &&
1072 !info
->attrs
[NFC_ATTR_LLC_PARAM_RW
] &&
1073 !info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
]))
1076 if (info
->attrs
[NFC_ATTR_LLC_PARAM_RW
]) {
1077 rw
= nla_get_u8(info
->attrs
[NFC_ATTR_LLC_PARAM_RW
]);
1079 if (rw
> LLCP_MAX_RW
)
1083 if (info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
]) {
1084 miux
= nla_get_u16(info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
]);
1086 if (miux
> LLCP_MAX_MIUX
)
1090 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1092 dev
= nfc_get_device(idx
);
1096 device_lock(&dev
->dev
);
1098 local
= nfc_llcp_find_local(dev
);
1100 nfc_put_device(dev
);
1105 if (info
->attrs
[NFC_ATTR_LLC_PARAM_LTO
]) {
1106 if (dev
->dep_link_up
) {
1111 local
->lto
= nla_get_u8(info
->attrs
[NFC_ATTR_LLC_PARAM_LTO
]);
1114 if (info
->attrs
[NFC_ATTR_LLC_PARAM_RW
])
1117 if (info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
])
1118 local
->miux
= cpu_to_be16(miux
);
1121 device_unlock(&dev
->dev
);
1123 nfc_put_device(dev
);
1128 static int nfc_genl_llc_sdreq(struct sk_buff
*skb
, struct genl_info
*info
)
1130 struct nfc_dev
*dev
;
1131 struct nfc_llcp_local
*local
;
1132 struct nlattr
*attr
, *sdp_attrs
[NFC_SDP_ATTR_MAX
+1];
1137 size_t uri_len
, tlvs_len
;
1138 struct hlist_head sdreq_list
;
1139 struct nfc_llcp_sdp_tlv
*sdreq
;
1141 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1142 !info
->attrs
[NFC_ATTR_LLC_SDP
])
1145 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1147 dev
= nfc_get_device(idx
);
1151 device_lock(&dev
->dev
);
1153 if (dev
->dep_link_up
== false) {
1158 local
= nfc_llcp_find_local(dev
);
1160 nfc_put_device(dev
);
1165 INIT_HLIST_HEAD(&sdreq_list
);
1169 nla_for_each_nested(attr
, info
->attrs
[NFC_ATTR_LLC_SDP
], rem
) {
1170 rc
= nla_parse_nested_deprecated(sdp_attrs
, NFC_SDP_ATTR_MAX
,
1171 attr
, nfc_sdp_genl_policy
,
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
);
1274 static int nfc_genl_enable_se(struct sk_buff
*skb
, struct genl_info
*info
)
1276 struct nfc_dev
*dev
;
1280 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1281 !info
->attrs
[NFC_ATTR_SE_INDEX
])
1284 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1285 se_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_SE_INDEX
]);
1287 dev
= nfc_get_device(idx
);
1291 rc
= nfc_enable_se(dev
, se_idx
);
1293 nfc_put_device(dev
);
1297 static int nfc_genl_disable_se(struct sk_buff
*skb
, struct genl_info
*info
)
1299 struct nfc_dev
*dev
;
1303 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1304 !info
->attrs
[NFC_ATTR_SE_INDEX
])
1307 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1308 se_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_SE_INDEX
]);
1310 dev
= nfc_get_device(idx
);
1314 rc
= nfc_disable_se(dev
, se_idx
);
1316 nfc_put_device(dev
);
1320 static int nfc_genl_send_se(struct sk_buff
*msg
, struct nfc_dev
*dev
,
1321 u32 portid
, u32 seq
,
1322 struct netlink_callback
*cb
,
1326 struct nfc_se
*se
, *n
;
1328 list_for_each_entry_safe(se
, n
, &dev
->secure_elements
, list
) {
1329 hdr
= genlmsg_put(msg
, portid
, seq
, &nfc_genl_family
, flags
,
1332 goto nla_put_failure
;
1335 genl_dump_check_consistent(cb
, hdr
);
1337 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
1338 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se
->idx
) ||
1339 nla_put_u8(msg
, NFC_ATTR_SE_TYPE
, se
->type
))
1340 goto nla_put_failure
;
1342 genlmsg_end(msg
, hdr
);
1348 genlmsg_cancel(msg
, hdr
);
1352 static int nfc_genl_dump_ses(struct sk_buff
*skb
,
1353 struct netlink_callback
*cb
)
1355 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
1356 struct nfc_dev
*dev
= (struct nfc_dev
*) cb
->args
[1];
1357 bool first_call
= false;
1361 iter
= kmalloc(sizeof(struct class_dev_iter
), GFP_KERNEL
);
1364 cb
->args
[0] = (long) iter
;
1367 mutex_lock(&nfc_devlist_mutex
);
1369 cb
->seq
= nfc_devlist_generation
;
1372 nfc_device_iter_init(iter
);
1373 dev
= nfc_device_iter_next(iter
);
1379 rc
= nfc_genl_send_se(skb
, dev
, NETLINK_CB(cb
->skb
).portid
,
1380 cb
->nlh
->nlmsg_seq
, cb
, NLM_F_MULTI
);
1384 dev
= nfc_device_iter_next(iter
);
1387 mutex_unlock(&nfc_devlist_mutex
);
1389 cb
->args
[1] = (long) dev
;
1394 static int nfc_genl_dump_ses_done(struct netlink_callback
*cb
)
1396 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
1398 nfc_device_iter_exit(iter
);
1404 static int nfc_se_io(struct nfc_dev
*dev
, u32 se_idx
,
1405 u8
*apdu
, size_t apdu_length
,
1406 se_io_cb_t cb
, void *cb_context
)
1411 pr_debug("%s se index %d\n", dev_name(&dev
->dev
), se_idx
);
1413 device_lock(&dev
->dev
);
1415 if (!device_is_registered(&dev
->dev
)) {
1425 if (!dev
->ops
->se_io
) {
1430 se
= nfc_find_se(dev
, se_idx
);
1436 if (se
->state
!= NFC_SE_ENABLED
) {
1441 rc
= dev
->ops
->se_io(dev
, se_idx
, apdu
,
1442 apdu_length
, cb
, cb_context
);
1445 device_unlock(&dev
->dev
);
1454 static void se_io_cb(void *context
, u8
*apdu
, size_t apdu_len
, int err
)
1456 struct se_io_ctx
*ctx
= context
;
1457 struct sk_buff
*msg
;
1460 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1466 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
1471 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, ctx
->dev_idx
) ||
1472 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, ctx
->se_idx
) ||
1473 nla_put(msg
, NFC_ATTR_SE_APDU
, apdu_len
, apdu
))
1474 goto nla_put_failure
;
1476 genlmsg_end(msg
, hdr
);
1478 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
1492 static int nfc_genl_se_io(struct sk_buff
*skb
, struct genl_info
*info
)
1494 struct nfc_dev
*dev
;
1495 struct se_io_ctx
*ctx
;
1496 u32 dev_idx
, se_idx
;
1500 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1501 !info
->attrs
[NFC_ATTR_SE_INDEX
] ||
1502 !info
->attrs
[NFC_ATTR_SE_APDU
])
1505 dev_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1506 se_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_SE_INDEX
]);
1508 dev
= nfc_get_device(dev_idx
);
1512 if (!dev
->ops
|| !dev
->ops
->se_io
)
1515 apdu_len
= nla_len(info
->attrs
[NFC_ATTR_SE_APDU
]);
1519 apdu
= nla_data(info
->attrs
[NFC_ATTR_SE_APDU
]);
1523 ctx
= kzalloc(sizeof(struct se_io_ctx
), GFP_KERNEL
);
1527 ctx
->dev_idx
= dev_idx
;
1528 ctx
->se_idx
= se_idx
;
1530 return nfc_se_io(dev
, se_idx
, apdu
, apdu_len
, se_io_cb
, ctx
);
1533 static int nfc_genl_vendor_cmd(struct sk_buff
*skb
,
1534 struct genl_info
*info
)
1536 struct nfc_dev
*dev
;
1537 struct nfc_vendor_cmd
*cmd
;
1538 u32 dev_idx
, vid
, subcmd
;
1543 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1544 !info
->attrs
[NFC_ATTR_VENDOR_ID
] ||
1545 !info
->attrs
[NFC_ATTR_VENDOR_SUBCMD
])
1548 dev_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1549 vid
= nla_get_u32(info
->attrs
[NFC_ATTR_VENDOR_ID
]);
1550 subcmd
= nla_get_u32(info
->attrs
[NFC_ATTR_VENDOR_SUBCMD
]);
1552 dev
= nfc_get_device(dev_idx
);
1553 if (!dev
|| !dev
->vendor_cmds
|| !dev
->n_vendor_cmds
)
1556 if (info
->attrs
[NFC_ATTR_VENDOR_DATA
]) {
1557 data
= nla_data(info
->attrs
[NFC_ATTR_VENDOR_DATA
]);
1558 data_len
= nla_len(info
->attrs
[NFC_ATTR_VENDOR_DATA
]);
1566 for (i
= 0; i
< dev
->n_vendor_cmds
; i
++) {
1567 cmd
= &dev
->vendor_cmds
[i
];
1569 if (cmd
->vendor_id
!= vid
|| cmd
->subcmd
!= subcmd
)
1572 dev
->cur_cmd_info
= info
;
1573 err
= cmd
->doit(dev
, data
, data_len
);
1574 dev
->cur_cmd_info
= NULL
;
1581 /* message building helper */
1582 static inline void *nfc_hdr_put(struct sk_buff
*skb
, u32 portid
, u32 seq
,
1585 /* since there is no private header just add the generic one */
1586 return genlmsg_put(skb
, portid
, seq
, &nfc_genl_family
, flags
, cmd
);
1589 static struct sk_buff
*
1590 __nfc_alloc_vendor_cmd_skb(struct nfc_dev
*dev
, int approxlen
,
1591 u32 portid
, u32 seq
,
1592 enum nfc_attrs attr
,
1593 u32 oui
, u32 subcmd
, gfp_t gfp
)
1595 struct sk_buff
*skb
;
1598 skb
= nlmsg_new(approxlen
+ 100, gfp
);
1602 hdr
= nfc_hdr_put(skb
, portid
, seq
, 0, NFC_CMD_VENDOR
);
1608 if (nla_put_u32(skb
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
1609 goto nla_put_failure
;
1610 if (nla_put_u32(skb
, NFC_ATTR_VENDOR_ID
, oui
))
1611 goto nla_put_failure
;
1612 if (nla_put_u32(skb
, NFC_ATTR_VENDOR_SUBCMD
, subcmd
))
1613 goto nla_put_failure
;
1615 ((void **)skb
->cb
)[0] = dev
;
1616 ((void **)skb
->cb
)[1] = hdr
;
1625 struct sk_buff
*__nfc_alloc_vendor_cmd_reply_skb(struct nfc_dev
*dev
,
1626 enum nfc_attrs attr
,
1627 u32 oui
, u32 subcmd
,
1630 if (WARN_ON(!dev
->cur_cmd_info
))
1633 return __nfc_alloc_vendor_cmd_skb(dev
, approxlen
,
1634 dev
->cur_cmd_info
->snd_portid
,
1635 dev
->cur_cmd_info
->snd_seq
, attr
,
1636 oui
, subcmd
, GFP_KERNEL
);
1638 EXPORT_SYMBOL(__nfc_alloc_vendor_cmd_reply_skb
);
1640 int nfc_vendor_cmd_reply(struct sk_buff
*skb
)
1642 struct nfc_dev
*dev
= ((void **)skb
->cb
)[0];
1643 void *hdr
= ((void **)skb
->cb
)[1];
1645 /* clear CB data for netlink core to own from now on */
1646 memset(skb
->cb
, 0, sizeof(skb
->cb
));
1648 if (WARN_ON(!dev
->cur_cmd_info
)) {
1653 genlmsg_end(skb
, hdr
);
1654 return genlmsg_reply(skb
, dev
->cur_cmd_info
);
1656 EXPORT_SYMBOL(nfc_vendor_cmd_reply
);
1658 static const struct genl_ops nfc_genl_ops
[] = {
1660 .cmd
= NFC_CMD_GET_DEVICE
,
1661 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1662 .doit
= nfc_genl_get_device
,
1663 .dumpit
= nfc_genl_dump_devices
,
1664 .done
= nfc_genl_dump_devices_done
,
1667 .cmd
= NFC_CMD_DEV_UP
,
1668 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1669 .doit
= nfc_genl_dev_up
,
1672 .cmd
= NFC_CMD_DEV_DOWN
,
1673 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1674 .doit
= nfc_genl_dev_down
,
1677 .cmd
= NFC_CMD_START_POLL
,
1678 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1679 .doit
= nfc_genl_start_poll
,
1682 .cmd
= NFC_CMD_STOP_POLL
,
1683 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1684 .doit
= nfc_genl_stop_poll
,
1687 .cmd
= NFC_CMD_DEP_LINK_UP
,
1688 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1689 .doit
= nfc_genl_dep_link_up
,
1692 .cmd
= NFC_CMD_DEP_LINK_DOWN
,
1693 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1694 .doit
= nfc_genl_dep_link_down
,
1697 .cmd
= NFC_CMD_GET_TARGET
,
1698 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1699 .dumpit
= nfc_genl_dump_targets
,
1700 .done
= nfc_genl_dump_targets_done
,
1703 .cmd
= NFC_CMD_LLC_GET_PARAMS
,
1704 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1705 .doit
= nfc_genl_llc_get_params
,
1708 .cmd
= NFC_CMD_LLC_SET_PARAMS
,
1709 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1710 .doit
= nfc_genl_llc_set_params
,
1713 .cmd
= NFC_CMD_LLC_SDREQ
,
1714 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1715 .doit
= nfc_genl_llc_sdreq
,
1718 .cmd
= NFC_CMD_FW_DOWNLOAD
,
1719 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1720 .doit
= nfc_genl_fw_download
,
1723 .cmd
= NFC_CMD_ENABLE_SE
,
1724 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1725 .doit
= nfc_genl_enable_se
,
1728 .cmd
= NFC_CMD_DISABLE_SE
,
1729 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1730 .doit
= nfc_genl_disable_se
,
1733 .cmd
= NFC_CMD_GET_SE
,
1734 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1735 .dumpit
= nfc_genl_dump_ses
,
1736 .done
= nfc_genl_dump_ses_done
,
1739 .cmd
= NFC_CMD_SE_IO
,
1740 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1741 .doit
= nfc_genl_se_io
,
1744 .cmd
= NFC_CMD_ACTIVATE_TARGET
,
1745 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1746 .doit
= nfc_genl_activate_target
,
1749 .cmd
= NFC_CMD_VENDOR
,
1750 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1751 .doit
= nfc_genl_vendor_cmd
,
1754 .cmd
= NFC_CMD_DEACTIVATE_TARGET
,
1755 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
1756 .doit
= nfc_genl_deactivate_target
,
1760 static struct genl_family nfc_genl_family __ro_after_init
= {
1762 .name
= NFC_GENL_NAME
,
1763 .version
= NFC_GENL_VERSION
,
1764 .maxattr
= NFC_ATTR_MAX
,
1765 .policy
= nfc_genl_policy
,
1766 .module
= THIS_MODULE
,
1767 .ops
= nfc_genl_ops
,
1768 .n_ops
= ARRAY_SIZE(nfc_genl_ops
),
1769 .mcgrps
= nfc_genl_mcgrps
,
1770 .n_mcgrps
= ARRAY_SIZE(nfc_genl_mcgrps
),
1774 struct urelease_work
{
1775 struct work_struct w
;
1779 static void nfc_urelease_event_work(struct work_struct
*work
)
1781 struct urelease_work
*w
= container_of(work
, struct urelease_work
, w
);
1782 struct class_dev_iter iter
;
1783 struct nfc_dev
*dev
;
1785 pr_debug("portid %d\n", w
->portid
);
1787 mutex_lock(&nfc_devlist_mutex
);
1789 nfc_device_iter_init(&iter
);
1790 dev
= nfc_device_iter_next(&iter
);
1793 mutex_lock(&dev
->genl_data
.genl_data_mutex
);
1795 if (dev
->genl_data
.poll_req_portid
== w
->portid
) {
1797 dev
->genl_data
.poll_req_portid
= 0;
1800 mutex_unlock(&dev
->genl_data
.genl_data_mutex
);
1802 dev
= nfc_device_iter_next(&iter
);
1805 nfc_device_iter_exit(&iter
);
1807 mutex_unlock(&nfc_devlist_mutex
);
1812 static int nfc_genl_rcv_nl_event(struct notifier_block
*this,
1813 unsigned long event
, void *ptr
)
1815 struct netlink_notify
*n
= ptr
;
1816 struct urelease_work
*w
;
1818 if (event
!= NETLINK_URELEASE
|| n
->protocol
!= NETLINK_GENERIC
)
1821 pr_debug("NETLINK_URELEASE event from id %d\n", n
->portid
);
1823 w
= kmalloc(sizeof(*w
), GFP_ATOMIC
);
1825 INIT_WORK((struct work_struct
*) w
, nfc_urelease_event_work
);
1826 w
->portid
= n
->portid
;
1827 schedule_work((struct work_struct
*) w
);
1834 void nfc_genl_data_init(struct nfc_genl_data
*genl_data
)
1836 genl_data
->poll_req_portid
= 0;
1837 mutex_init(&genl_data
->genl_data_mutex
);
1840 void nfc_genl_data_exit(struct nfc_genl_data
*genl_data
)
1842 mutex_destroy(&genl_data
->genl_data_mutex
);
1845 static struct notifier_block nl_notifier
= {
1846 .notifier_call
= nfc_genl_rcv_nl_event
,
1850 * nfc_genl_init() - Initialize netlink interface
1852 * This initialization function registers the nfc netlink family.
1854 int __init
nfc_genl_init(void)
1858 rc
= genl_register_family(&nfc_genl_family
);
1862 netlink_register_notifier(&nl_notifier
);
1868 * nfc_genl_exit() - Deinitialize netlink interface
1870 * This exit function unregisters the nfc netlink family.
1872 void nfc_genl_exit(void)
1874 netlink_unregister_notifier(&nl_notifier
);
1875 genl_unregister_family(&nfc_genl_family
);