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 * 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.
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.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the
20 * Free Software Foundation, Inc.,
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
26 #include <net/genetlink.h>
27 #include <linux/nfc.h>
28 #include <linux/slab.h>
33 static struct genl_multicast_group nfc_genl_event_mcgrp
= {
34 .name
= NFC_GENL_MCAST_EVENT_NAME
,
37 static struct genl_family nfc_genl_family
= {
38 .id
= GENL_ID_GENERATE
,
40 .name
= NFC_GENL_NAME
,
41 .version
= NFC_GENL_VERSION
,
42 .maxattr
= NFC_ATTR_MAX
,
45 static const struct nla_policy nfc_genl_policy
[NFC_ATTR_MAX
+ 1] = {
46 [NFC_ATTR_DEVICE_INDEX
] = { .type
= NLA_U32
},
47 [NFC_ATTR_DEVICE_NAME
] = { .type
= NLA_STRING
,
48 .len
= NFC_DEVICE_NAME_MAXSIZE
},
49 [NFC_ATTR_PROTOCOLS
] = { .type
= NLA_U32
},
50 [NFC_ATTR_COMM_MODE
] = { .type
= NLA_U8
},
51 [NFC_ATTR_RF_MODE
] = { .type
= NLA_U8
},
52 [NFC_ATTR_DEVICE_POWERED
] = { .type
= NLA_U8
},
53 [NFC_ATTR_IM_PROTOCOLS
] = { .type
= NLA_U32
},
54 [NFC_ATTR_TM_PROTOCOLS
] = { .type
= NLA_U32
},
55 [NFC_ATTR_LLC_PARAM_LTO
] = { .type
= NLA_U8
},
56 [NFC_ATTR_LLC_PARAM_RW
] = { .type
= NLA_U8
},
57 [NFC_ATTR_LLC_PARAM_MIUX
] = { .type
= NLA_U16
},
58 [NFC_ATTR_LLC_SDP
] = { .type
= NLA_NESTED
},
59 [NFC_ATTR_FIRMWARE_NAME
] = { .type
= NLA_STRING
,
60 .len
= NFC_FIRMWARE_NAME_MAXSIZE
},
61 [NFC_ATTR_SE_APDU
] = { .type
= NLA_BINARY
},
64 static const struct nla_policy nfc_sdp_genl_policy
[NFC_SDP_ATTR_MAX
+ 1] = {
65 [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 return genlmsg_end(msg
, hdr
);
102 genlmsg_cancel(msg
, hdr
);
106 static struct nfc_dev
*__get_device_from_cb(struct netlink_callback
*cb
)
112 rc
= nlmsg_parse(cb
->nlh
, GENL_HDRLEN
+ nfc_genl_family
.hdrsize
,
113 nfc_genl_family
.attrbuf
,
114 nfc_genl_family
.maxattr
,
119 if (!nfc_genl_family
.attrbuf
[NFC_ATTR_DEVICE_INDEX
])
120 return ERR_PTR(-EINVAL
);
122 idx
= nla_get_u32(nfc_genl_family
.attrbuf
[NFC_ATTR_DEVICE_INDEX
]);
124 dev
= nfc_get_device(idx
);
126 return ERR_PTR(-ENODEV
);
131 static int nfc_genl_dump_targets(struct sk_buff
*skb
,
132 struct netlink_callback
*cb
)
135 struct nfc_dev
*dev
= (struct nfc_dev
*) cb
->args
[1];
139 dev
= __get_device_from_cb(cb
);
143 cb
->args
[1] = (long) dev
;
146 device_lock(&dev
->dev
);
148 cb
->seq
= dev
->targets_generation
;
150 while (i
< dev
->n_targets
) {
151 rc
= nfc_genl_send_target(skb
, &dev
->targets
[i
], cb
,
159 device_unlock(&dev
->dev
);
166 static int nfc_genl_dump_targets_done(struct netlink_callback
*cb
)
168 struct nfc_dev
*dev
= (struct nfc_dev
*) cb
->args
[1];
176 int nfc_genl_targets_found(struct nfc_dev
*dev
)
181 dev
->genl_data
.poll_req_portid
= 0;
183 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
187 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
188 NFC_EVENT_TARGETS_FOUND
);
192 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
193 goto nla_put_failure
;
195 genlmsg_end(msg
, hdr
);
197 return genlmsg_multicast(&nfc_genl_family
, msg
, 0,
198 nfc_genl_event_mcgrp
.id
, GFP_ATOMIC
);
201 genlmsg_cancel(msg
, hdr
);
207 int nfc_genl_target_lost(struct nfc_dev
*dev
, u32 target_idx
)
212 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
216 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
217 NFC_EVENT_TARGET_LOST
);
221 if (nla_put_string(msg
, NFC_ATTR_DEVICE_NAME
, nfc_device_name(dev
)) ||
222 nla_put_u32(msg
, NFC_ATTR_TARGET_INDEX
, target_idx
))
223 goto nla_put_failure
;
225 genlmsg_end(msg
, hdr
);
227 genlmsg_multicast(&nfc_genl_family
, msg
, 0,
228 nfc_genl_event_mcgrp
.id
, GFP_KERNEL
);
233 genlmsg_cancel(msg
, hdr
);
239 int nfc_genl_tm_activated(struct nfc_dev
*dev
, u32 protocol
)
244 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
248 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
249 NFC_EVENT_TM_ACTIVATED
);
253 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
254 goto nla_put_failure
;
255 if (nla_put_u32(msg
, NFC_ATTR_TM_PROTOCOLS
, protocol
))
256 goto nla_put_failure
;
258 genlmsg_end(msg
, hdr
);
260 genlmsg_multicast(&nfc_genl_family
, msg
, 0,
261 nfc_genl_event_mcgrp
.id
, GFP_KERNEL
);
266 genlmsg_cancel(msg
, hdr
);
272 int nfc_genl_tm_deactivated(struct nfc_dev
*dev
)
277 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
281 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
282 NFC_EVENT_TM_DEACTIVATED
);
286 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
287 goto nla_put_failure
;
289 genlmsg_end(msg
, hdr
);
291 genlmsg_multicast(&nfc_genl_family
, msg
, 0,
292 nfc_genl_event_mcgrp
.id
, GFP_KERNEL
);
297 genlmsg_cancel(msg
, hdr
);
303 int nfc_genl_device_added(struct nfc_dev
*dev
)
308 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
312 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
313 NFC_EVENT_DEVICE_ADDED
);
317 if (nla_put_string(msg
, NFC_ATTR_DEVICE_NAME
, nfc_device_name(dev
)) ||
318 nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
319 nla_put_u32(msg
, NFC_ATTR_PROTOCOLS
, dev
->supported_protocols
) ||
320 nla_put_u8(msg
, NFC_ATTR_DEVICE_POWERED
, dev
->dev_up
))
321 goto nla_put_failure
;
323 genlmsg_end(msg
, hdr
);
325 genlmsg_multicast(&nfc_genl_family
, msg
, 0,
326 nfc_genl_event_mcgrp
.id
, GFP_KERNEL
);
331 genlmsg_cancel(msg
, hdr
);
337 int nfc_genl_device_removed(struct nfc_dev
*dev
)
342 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
346 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
347 NFC_EVENT_DEVICE_REMOVED
);
351 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
352 goto nla_put_failure
;
354 genlmsg_end(msg
, hdr
);
356 genlmsg_multicast(&nfc_genl_family
, msg
, 0,
357 nfc_genl_event_mcgrp
.id
, GFP_KERNEL
);
362 genlmsg_cancel(msg
, hdr
);
368 int nfc_genl_llc_send_sdres(struct nfc_dev
*dev
, struct hlist_head
*sdres_list
)
371 struct nlattr
*sdp_attr
, *uri_attr
;
372 struct nfc_llcp_sdp_tlv
*sdres
;
373 struct hlist_node
*n
;
378 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
382 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
383 NFC_EVENT_LLC_SDRES
);
387 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
388 goto nla_put_failure
;
390 sdp_attr
= nla_nest_start(msg
, NFC_ATTR_LLC_SDP
);
391 if (sdp_attr
== NULL
) {
393 goto nla_put_failure
;
397 hlist_for_each_entry_safe(sdres
, n
, sdres_list
, node
) {
398 pr_debug("uri: %s, sap: %d\n", sdres
->uri
, sdres
->sap
);
400 uri_attr
= nla_nest_start(msg
, i
++);
401 if (uri_attr
== NULL
) {
403 goto nla_put_failure
;
406 if (nla_put_u8(msg
, NFC_SDP_ATTR_SAP
, sdres
->sap
))
407 goto nla_put_failure
;
409 if (nla_put_string(msg
, NFC_SDP_ATTR_URI
, sdres
->uri
))
410 goto nla_put_failure
;
412 nla_nest_end(msg
, uri_attr
);
414 hlist_del(&sdres
->node
);
416 nfc_llcp_free_sdp_tlv(sdres
);
419 nla_nest_end(msg
, sdp_attr
);
421 genlmsg_end(msg
, hdr
);
423 return genlmsg_multicast(&nfc_genl_family
, msg
, 0,
424 nfc_genl_event_mcgrp
.id
, GFP_ATOMIC
);
427 genlmsg_cancel(msg
, hdr
);
432 nfc_llcp_free_sdp_tlv_list(sdres_list
);
437 int nfc_genl_se_added(struct nfc_dev
*dev
, u32 se_idx
, u16 type
)
442 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
446 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
451 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
452 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se_idx
) ||
453 nla_put_u8(msg
, NFC_ATTR_SE_TYPE
, type
))
454 goto nla_put_failure
;
456 genlmsg_end(msg
, hdr
);
458 genlmsg_multicast(&nfc_genl_family
, msg
, 0,
459 nfc_genl_event_mcgrp
.id
, GFP_KERNEL
);
464 genlmsg_cancel(msg
, hdr
);
470 int nfc_genl_se_removed(struct nfc_dev
*dev
, u32 se_idx
)
475 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
479 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
480 NFC_EVENT_SE_REMOVED
);
484 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
485 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se_idx
))
486 goto nla_put_failure
;
488 genlmsg_end(msg
, hdr
);
490 genlmsg_multicast(&nfc_genl_family
, msg
, 0,
491 nfc_genl_event_mcgrp
.id
, GFP_KERNEL
);
496 genlmsg_cancel(msg
, hdr
);
502 static int nfc_genl_send_device(struct sk_buff
*msg
, struct nfc_dev
*dev
,
504 struct netlink_callback
*cb
,
509 hdr
= genlmsg_put(msg
, portid
, seq
, &nfc_genl_family
, flags
,
515 genl_dump_check_consistent(cb
, hdr
, &nfc_genl_family
);
517 if (nla_put_string(msg
, NFC_ATTR_DEVICE_NAME
, nfc_device_name(dev
)) ||
518 nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
519 nla_put_u32(msg
, NFC_ATTR_PROTOCOLS
, dev
->supported_protocols
) ||
520 nla_put_u8(msg
, NFC_ATTR_DEVICE_POWERED
, dev
->dev_up
) ||
521 nla_put_u8(msg
, NFC_ATTR_RF_MODE
, dev
->rf_mode
))
522 goto nla_put_failure
;
524 return genlmsg_end(msg
, hdr
);
527 genlmsg_cancel(msg
, hdr
);
531 static int nfc_genl_dump_devices(struct sk_buff
*skb
,
532 struct netlink_callback
*cb
)
534 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
535 struct nfc_dev
*dev
= (struct nfc_dev
*) cb
->args
[1];
536 bool first_call
= false;
540 iter
= kmalloc(sizeof(struct class_dev_iter
), GFP_KERNEL
);
543 cb
->args
[0] = (long) iter
;
546 mutex_lock(&nfc_devlist_mutex
);
548 cb
->seq
= nfc_devlist_generation
;
551 nfc_device_iter_init(iter
);
552 dev
= nfc_device_iter_next(iter
);
558 rc
= nfc_genl_send_device(skb
, dev
, NETLINK_CB(cb
->skb
).portid
,
559 cb
->nlh
->nlmsg_seq
, cb
, NLM_F_MULTI
);
563 dev
= nfc_device_iter_next(iter
);
566 mutex_unlock(&nfc_devlist_mutex
);
568 cb
->args
[1] = (long) dev
;
573 static int nfc_genl_dump_devices_done(struct netlink_callback
*cb
)
575 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
577 nfc_device_iter_exit(iter
);
583 int nfc_genl_dep_link_up_event(struct nfc_dev
*dev
, u32 target_idx
,
584 u8 comm_mode
, u8 rf_mode
)
589 pr_debug("DEP link is up\n");
591 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
595 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0, NFC_CMD_DEP_LINK_UP
);
599 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
600 goto nla_put_failure
;
601 if (rf_mode
== NFC_RF_INITIATOR
&&
602 nla_put_u32(msg
, NFC_ATTR_TARGET_INDEX
, target_idx
))
603 goto nla_put_failure
;
604 if (nla_put_u8(msg
, NFC_ATTR_COMM_MODE
, comm_mode
) ||
605 nla_put_u8(msg
, NFC_ATTR_RF_MODE
, rf_mode
))
606 goto nla_put_failure
;
608 genlmsg_end(msg
, hdr
);
610 dev
->dep_link_up
= true;
612 genlmsg_multicast(&nfc_genl_family
, msg
, 0,
613 nfc_genl_event_mcgrp
.id
, GFP_ATOMIC
);
618 genlmsg_cancel(msg
, hdr
);
624 int nfc_genl_dep_link_down_event(struct nfc_dev
*dev
)
629 pr_debug("DEP link is down\n");
631 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
635 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
636 NFC_CMD_DEP_LINK_DOWN
);
640 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
641 goto nla_put_failure
;
643 genlmsg_end(msg
, hdr
);
645 genlmsg_multicast(&nfc_genl_family
, msg
, 0,
646 nfc_genl_event_mcgrp
.id
, GFP_ATOMIC
);
651 genlmsg_cancel(msg
, hdr
);
657 static int nfc_genl_get_device(struct sk_buff
*skb
, struct genl_info
*info
)
664 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
667 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
669 dev
= nfc_get_device(idx
);
673 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
679 rc
= nfc_genl_send_device(msg
, dev
, info
->snd_portid
, info
->snd_seq
,
686 return genlmsg_reply(msg
, info
);
695 static int nfc_genl_dev_up(struct sk_buff
*skb
, struct genl_info
*info
)
701 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
704 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
706 dev
= nfc_get_device(idx
);
710 rc
= nfc_dev_up(dev
);
716 static int nfc_genl_dev_down(struct sk_buff
*skb
, struct genl_info
*info
)
722 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
725 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
727 dev
= nfc_get_device(idx
);
731 rc
= nfc_dev_down(dev
);
737 static int nfc_genl_start_poll(struct sk_buff
*skb
, struct genl_info
*info
)
742 u32 im_protocols
= 0, tm_protocols
= 0;
744 pr_debug("Poll start\n");
746 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
747 ((!info
->attrs
[NFC_ATTR_IM_PROTOCOLS
] &&
748 !info
->attrs
[NFC_ATTR_PROTOCOLS
]) &&
749 !info
->attrs
[NFC_ATTR_TM_PROTOCOLS
]))
752 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
754 if (info
->attrs
[NFC_ATTR_TM_PROTOCOLS
])
755 tm_protocols
= nla_get_u32(info
->attrs
[NFC_ATTR_TM_PROTOCOLS
]);
757 if (info
->attrs
[NFC_ATTR_IM_PROTOCOLS
])
758 im_protocols
= nla_get_u32(info
->attrs
[NFC_ATTR_IM_PROTOCOLS
]);
759 else if (info
->attrs
[NFC_ATTR_PROTOCOLS
])
760 im_protocols
= nla_get_u32(info
->attrs
[NFC_ATTR_PROTOCOLS
]);
762 dev
= nfc_get_device(idx
);
766 mutex_lock(&dev
->genl_data
.genl_data_mutex
);
768 rc
= nfc_start_poll(dev
, im_protocols
, tm_protocols
);
770 dev
->genl_data
.poll_req_portid
= info
->snd_portid
;
772 mutex_unlock(&dev
->genl_data
.genl_data_mutex
);
778 static int nfc_genl_stop_poll(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 device_lock(&dev
->dev
);
796 device_unlock(&dev
->dev
);
800 device_unlock(&dev
->dev
);
802 mutex_lock(&dev
->genl_data
.genl_data_mutex
);
804 if (dev
->genl_data
.poll_req_portid
!= info
->snd_portid
) {
809 rc
= nfc_stop_poll(dev
);
810 dev
->genl_data
.poll_req_portid
= 0;
813 mutex_unlock(&dev
->genl_data
.genl_data_mutex
);
818 static int nfc_genl_dep_link_up(struct sk_buff
*skb
, struct genl_info
*info
)
825 pr_debug("DEP link up\n");
827 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
828 !info
->attrs
[NFC_ATTR_COMM_MODE
])
831 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
832 if (!info
->attrs
[NFC_ATTR_TARGET_INDEX
])
833 tgt_idx
= NFC_TARGET_IDX_ANY
;
835 tgt_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_TARGET_INDEX
]);
837 comm
= nla_get_u8(info
->attrs
[NFC_ATTR_COMM_MODE
]);
839 if (comm
!= NFC_COMM_ACTIVE
&& comm
!= NFC_COMM_PASSIVE
)
842 dev
= nfc_get_device(idx
);
846 rc
= nfc_dep_link_up(dev
, tgt_idx
, comm
);
853 static int nfc_genl_dep_link_down(struct sk_buff
*skb
, struct genl_info
*info
)
859 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
862 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
864 dev
= nfc_get_device(idx
);
868 rc
= nfc_dep_link_down(dev
);
874 static int nfc_genl_send_params(struct sk_buff
*msg
,
875 struct nfc_llcp_local
*local
,
880 hdr
= genlmsg_put(msg
, portid
, seq
, &nfc_genl_family
, 0,
881 NFC_CMD_LLC_GET_PARAMS
);
885 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, local
->dev
->idx
) ||
886 nla_put_u8(msg
, NFC_ATTR_LLC_PARAM_LTO
, local
->lto
) ||
887 nla_put_u8(msg
, NFC_ATTR_LLC_PARAM_RW
, local
->rw
) ||
888 nla_put_u16(msg
, NFC_ATTR_LLC_PARAM_MIUX
, be16_to_cpu(local
->miux
)))
889 goto nla_put_failure
;
891 return genlmsg_end(msg
, hdr
);
895 genlmsg_cancel(msg
, hdr
);
899 static int nfc_genl_llc_get_params(struct sk_buff
*skb
, struct genl_info
*info
)
902 struct nfc_llcp_local
*local
;
904 struct sk_buff
*msg
= NULL
;
907 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
910 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
912 dev
= nfc_get_device(idx
);
916 device_lock(&dev
->dev
);
918 local
= nfc_llcp_find_local(dev
);
924 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
930 rc
= nfc_genl_send_params(msg
, local
, info
->snd_portid
, info
->snd_seq
);
933 device_unlock(&dev
->dev
);
944 return genlmsg_reply(msg
, info
);
947 static int nfc_genl_llc_set_params(struct sk_buff
*skb
, struct genl_info
*info
)
950 struct nfc_llcp_local
*local
;
956 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
957 (!info
->attrs
[NFC_ATTR_LLC_PARAM_LTO
] &&
958 !info
->attrs
[NFC_ATTR_LLC_PARAM_RW
] &&
959 !info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
]))
962 if (info
->attrs
[NFC_ATTR_LLC_PARAM_RW
]) {
963 rw
= nla_get_u8(info
->attrs
[NFC_ATTR_LLC_PARAM_RW
]);
965 if (rw
> LLCP_MAX_RW
)
969 if (info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
]) {
970 miux
= nla_get_u16(info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
]);
972 if (miux
> LLCP_MAX_MIUX
)
976 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
978 dev
= nfc_get_device(idx
);
982 device_lock(&dev
->dev
);
984 local
= nfc_llcp_find_local(dev
);
991 if (info
->attrs
[NFC_ATTR_LLC_PARAM_LTO
]) {
992 if (dev
->dep_link_up
) {
997 local
->lto
= nla_get_u8(info
->attrs
[NFC_ATTR_LLC_PARAM_LTO
]);
1000 if (info
->attrs
[NFC_ATTR_LLC_PARAM_RW
])
1003 if (info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
])
1004 local
->miux
= cpu_to_be16(miux
);
1007 device_unlock(&dev
->dev
);
1009 nfc_put_device(dev
);
1014 static int nfc_genl_llc_sdreq(struct sk_buff
*skb
, struct genl_info
*info
)
1016 struct nfc_dev
*dev
;
1017 struct nfc_llcp_local
*local
;
1018 struct nlattr
*attr
, *sdp_attrs
[NFC_SDP_ATTR_MAX
+1];
1023 size_t uri_len
, tlvs_len
;
1024 struct hlist_head sdreq_list
;
1025 struct nfc_llcp_sdp_tlv
*sdreq
;
1027 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1028 !info
->attrs
[NFC_ATTR_LLC_SDP
])
1031 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1033 dev
= nfc_get_device(idx
);
1039 device_lock(&dev
->dev
);
1041 if (dev
->dep_link_up
== false) {
1046 local
= nfc_llcp_find_local(dev
);
1048 nfc_put_device(dev
);
1053 INIT_HLIST_HEAD(&sdreq_list
);
1057 nla_for_each_nested(attr
, info
->attrs
[NFC_ATTR_LLC_SDP
], rem
) {
1058 rc
= nla_parse_nested(sdp_attrs
, NFC_SDP_ATTR_MAX
, attr
,
1059 nfc_sdp_genl_policy
);
1066 if (!sdp_attrs
[NFC_SDP_ATTR_URI
])
1069 uri_len
= nla_len(sdp_attrs
[NFC_SDP_ATTR_URI
]);
1073 uri
= nla_data(sdp_attrs
[NFC_SDP_ATTR_URI
]);
1074 if (uri
== NULL
|| *uri
== 0)
1077 tid
= local
->sdreq_next_tid
++;
1079 sdreq
= nfc_llcp_build_sdreq_tlv(tid
, uri
, uri_len
);
1080 if (sdreq
== NULL
) {
1085 tlvs_len
+= sdreq
->tlv_len
;
1087 hlist_add_head(&sdreq
->node
, &sdreq_list
);
1090 if (hlist_empty(&sdreq_list
)) {
1095 rc
= nfc_llcp_send_snl_sdreq(local
, &sdreq_list
, tlvs_len
);
1097 device_unlock(&dev
->dev
);
1099 nfc_put_device(dev
);
1104 static int nfc_genl_fw_download(struct sk_buff
*skb
, struct genl_info
*info
)
1106 struct nfc_dev
*dev
;
1109 char firmware_name
[NFC_FIRMWARE_NAME_MAXSIZE
+ 1];
1111 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
1114 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1116 dev
= nfc_get_device(idx
);
1120 nla_strlcpy(firmware_name
, info
->attrs
[NFC_ATTR_FIRMWARE_NAME
],
1121 sizeof(firmware_name
));
1123 rc
= nfc_fw_download(dev
, firmware_name
);
1125 nfc_put_device(dev
);
1129 int nfc_genl_fw_download_done(struct nfc_dev
*dev
, const char *firmware_name
,
1132 struct sk_buff
*msg
;
1135 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1139 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
1140 NFC_CMD_FW_DOWNLOAD
);
1144 if (nla_put_string(msg
, NFC_ATTR_FIRMWARE_NAME
, firmware_name
) ||
1145 nla_put_u32(msg
, NFC_ATTR_FIRMWARE_DOWNLOAD_STATUS
, result
) ||
1146 nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
1147 goto nla_put_failure
;
1149 genlmsg_end(msg
, hdr
);
1151 genlmsg_multicast(&nfc_genl_family
, msg
, 0,
1152 nfc_genl_event_mcgrp
.id
, GFP_KERNEL
);
1157 genlmsg_cancel(msg
, hdr
);
1163 static int nfc_genl_enable_se(struct sk_buff
*skb
, struct genl_info
*info
)
1165 struct nfc_dev
*dev
;
1169 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1170 !info
->attrs
[NFC_ATTR_SE_INDEX
])
1173 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1174 se_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_SE_INDEX
]);
1176 dev
= nfc_get_device(idx
);
1180 rc
= nfc_enable_se(dev
, se_idx
);
1182 nfc_put_device(dev
);
1186 static int nfc_genl_disable_se(struct sk_buff
*skb
, struct genl_info
*info
)
1188 struct nfc_dev
*dev
;
1192 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1193 !info
->attrs
[NFC_ATTR_SE_INDEX
])
1196 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1197 se_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_SE_INDEX
]);
1199 dev
= nfc_get_device(idx
);
1203 rc
= nfc_disable_se(dev
, se_idx
);
1205 nfc_put_device(dev
);
1209 static int nfc_genl_send_se(struct sk_buff
*msg
, struct nfc_dev
*dev
,
1210 u32 portid
, u32 seq
,
1211 struct netlink_callback
*cb
,
1215 struct nfc_se
*se
, *n
;
1217 list_for_each_entry_safe(se
, n
, &dev
->secure_elements
, list
) {
1218 hdr
= genlmsg_put(msg
, portid
, seq
, &nfc_genl_family
, flags
,
1221 goto nla_put_failure
;
1224 genl_dump_check_consistent(cb
, hdr
, &nfc_genl_family
);
1226 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
1227 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se
->idx
) ||
1228 nla_put_u8(msg
, NFC_ATTR_SE_TYPE
, se
->type
))
1229 goto nla_put_failure
;
1231 if (genlmsg_end(msg
, hdr
) < 0)
1232 goto nla_put_failure
;
1238 genlmsg_cancel(msg
, hdr
);
1242 static int nfc_genl_dump_ses(struct sk_buff
*skb
,
1243 struct netlink_callback
*cb
)
1245 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
1246 struct nfc_dev
*dev
= (struct nfc_dev
*) cb
->args
[1];
1247 bool first_call
= false;
1251 iter
= kmalloc(sizeof(struct class_dev_iter
), GFP_KERNEL
);
1254 cb
->args
[0] = (long) iter
;
1257 mutex_lock(&nfc_devlist_mutex
);
1259 cb
->seq
= nfc_devlist_generation
;
1262 nfc_device_iter_init(iter
);
1263 dev
= nfc_device_iter_next(iter
);
1269 rc
= nfc_genl_send_se(skb
, dev
, NETLINK_CB(cb
->skb
).portid
,
1270 cb
->nlh
->nlmsg_seq
, cb
, NLM_F_MULTI
);
1274 dev
= nfc_device_iter_next(iter
);
1277 mutex_unlock(&nfc_devlist_mutex
);
1279 cb
->args
[1] = (long) dev
;
1284 static int nfc_genl_dump_ses_done(struct netlink_callback
*cb
)
1286 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
1288 nfc_device_iter_exit(iter
);
1299 static void se_io_cb(void *context
, u8
*apdu
, size_t apdu_len
, int err
)
1301 struct se_io_ctx
*ctx
= context
;
1302 struct sk_buff
*msg
;
1305 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1311 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
1316 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, ctx
->dev_idx
) ||
1317 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, ctx
->se_idx
) ||
1318 nla_put(msg
, NFC_ATTR_SE_APDU
, apdu_len
, apdu
))
1319 goto nla_put_failure
;
1321 genlmsg_end(msg
, hdr
);
1323 genlmsg_multicast(&nfc_genl_family
, msg
, 0,
1324 nfc_genl_event_mcgrp
.id
, GFP_KERNEL
);
1331 genlmsg_cancel(msg
, hdr
);
1339 static int nfc_genl_se_io(struct sk_buff
*skb
, struct genl_info
*info
)
1341 struct nfc_dev
*dev
;
1342 struct se_io_ctx
*ctx
;
1343 u32 dev_idx
, se_idx
;
1347 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1348 !info
->attrs
[NFC_ATTR_SE_INDEX
] ||
1349 !info
->attrs
[NFC_ATTR_SE_APDU
])
1352 dev_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1353 se_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_SE_INDEX
]);
1355 dev
= nfc_get_device(dev_idx
);
1359 if (!dev
->ops
|| !dev
->ops
->se_io
)
1362 apdu_len
= nla_len(info
->attrs
[NFC_ATTR_SE_APDU
]);
1366 apdu
= nla_data(info
->attrs
[NFC_ATTR_SE_APDU
]);
1370 ctx
= kzalloc(sizeof(struct se_io_ctx
), GFP_KERNEL
);
1374 ctx
->dev_idx
= dev_idx
;
1375 ctx
->se_idx
= se_idx
;
1377 return dev
->ops
->se_io(dev
, se_idx
, apdu
, apdu_len
, se_io_cb
, ctx
);
1380 static const struct genl_ops nfc_genl_ops
[] = {
1382 .cmd
= NFC_CMD_GET_DEVICE
,
1383 .doit
= nfc_genl_get_device
,
1384 .dumpit
= nfc_genl_dump_devices
,
1385 .done
= nfc_genl_dump_devices_done
,
1386 .policy
= nfc_genl_policy
,
1389 .cmd
= NFC_CMD_DEV_UP
,
1390 .doit
= nfc_genl_dev_up
,
1391 .policy
= nfc_genl_policy
,
1394 .cmd
= NFC_CMD_DEV_DOWN
,
1395 .doit
= nfc_genl_dev_down
,
1396 .policy
= nfc_genl_policy
,
1399 .cmd
= NFC_CMD_START_POLL
,
1400 .doit
= nfc_genl_start_poll
,
1401 .policy
= nfc_genl_policy
,
1404 .cmd
= NFC_CMD_STOP_POLL
,
1405 .doit
= nfc_genl_stop_poll
,
1406 .policy
= nfc_genl_policy
,
1409 .cmd
= NFC_CMD_DEP_LINK_UP
,
1410 .doit
= nfc_genl_dep_link_up
,
1411 .policy
= nfc_genl_policy
,
1414 .cmd
= NFC_CMD_DEP_LINK_DOWN
,
1415 .doit
= nfc_genl_dep_link_down
,
1416 .policy
= nfc_genl_policy
,
1419 .cmd
= NFC_CMD_GET_TARGET
,
1420 .dumpit
= nfc_genl_dump_targets
,
1421 .done
= nfc_genl_dump_targets_done
,
1422 .policy
= nfc_genl_policy
,
1425 .cmd
= NFC_CMD_LLC_GET_PARAMS
,
1426 .doit
= nfc_genl_llc_get_params
,
1427 .policy
= nfc_genl_policy
,
1430 .cmd
= NFC_CMD_LLC_SET_PARAMS
,
1431 .doit
= nfc_genl_llc_set_params
,
1432 .policy
= nfc_genl_policy
,
1435 .cmd
= NFC_CMD_LLC_SDREQ
,
1436 .doit
= nfc_genl_llc_sdreq
,
1437 .policy
= nfc_genl_policy
,
1440 .cmd
= NFC_CMD_FW_DOWNLOAD
,
1441 .doit
= nfc_genl_fw_download
,
1442 .policy
= nfc_genl_policy
,
1445 .cmd
= NFC_CMD_ENABLE_SE
,
1446 .doit
= nfc_genl_enable_se
,
1447 .policy
= nfc_genl_policy
,
1450 .cmd
= NFC_CMD_DISABLE_SE
,
1451 .doit
= nfc_genl_disable_se
,
1452 .policy
= nfc_genl_policy
,
1455 .cmd
= NFC_CMD_GET_SE
,
1456 .dumpit
= nfc_genl_dump_ses
,
1457 .done
= nfc_genl_dump_ses_done
,
1458 .policy
= nfc_genl_policy
,
1461 .cmd
= NFC_CMD_SE_IO
,
1462 .doit
= nfc_genl_se_io
,
1463 .policy
= nfc_genl_policy
,
1468 struct urelease_work
{
1469 struct work_struct w
;
1473 static void nfc_urelease_event_work(struct work_struct
*work
)
1475 struct urelease_work
*w
= container_of(work
, struct urelease_work
, w
);
1476 struct class_dev_iter iter
;
1477 struct nfc_dev
*dev
;
1479 pr_debug("portid %d\n", w
->portid
);
1481 mutex_lock(&nfc_devlist_mutex
);
1483 nfc_device_iter_init(&iter
);
1484 dev
= nfc_device_iter_next(&iter
);
1487 mutex_lock(&dev
->genl_data
.genl_data_mutex
);
1489 if (dev
->genl_data
.poll_req_portid
== w
->portid
) {
1491 dev
->genl_data
.poll_req_portid
= 0;
1494 mutex_unlock(&dev
->genl_data
.genl_data_mutex
);
1496 dev
= nfc_device_iter_next(&iter
);
1499 nfc_device_iter_exit(&iter
);
1501 mutex_unlock(&nfc_devlist_mutex
);
1506 static int nfc_genl_rcv_nl_event(struct notifier_block
*this,
1507 unsigned long event
, void *ptr
)
1509 struct netlink_notify
*n
= ptr
;
1510 struct urelease_work
*w
;
1512 if (event
!= NETLINK_URELEASE
|| n
->protocol
!= NETLINK_GENERIC
)
1515 pr_debug("NETLINK_URELEASE event from id %d\n", n
->portid
);
1517 w
= kmalloc(sizeof(*w
), GFP_ATOMIC
);
1519 INIT_WORK((struct work_struct
*) w
, nfc_urelease_event_work
);
1520 w
->portid
= n
->portid
;
1521 schedule_work((struct work_struct
*) w
);
1528 void nfc_genl_data_init(struct nfc_genl_data
*genl_data
)
1530 genl_data
->poll_req_portid
= 0;
1531 mutex_init(&genl_data
->genl_data_mutex
);
1534 void nfc_genl_data_exit(struct nfc_genl_data
*genl_data
)
1536 mutex_destroy(&genl_data
->genl_data_mutex
);
1539 static struct notifier_block nl_notifier
= {
1540 .notifier_call
= nfc_genl_rcv_nl_event
,
1544 * nfc_genl_init() - Initialize netlink interface
1546 * This initialization function registers the nfc netlink family.
1548 int __init
nfc_genl_init(void)
1552 rc
= genl_register_family_with_ops(&nfc_genl_family
, nfc_genl_ops
);
1556 rc
= genl_register_mc_group(&nfc_genl_family
, &nfc_genl_event_mcgrp
);
1558 netlink_register_notifier(&nl_notifier
);
1564 * nfc_genl_exit() - Deinitialize netlink interface
1566 * This exit function unregisters the nfc netlink family.
1568 void nfc_genl_exit(void)
1570 netlink_unregister_notifier(&nl_notifier
);
1571 genl_unregister_family(&nfc_genl_family
);