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, see <http://www.gnu.org/licenses/>.
22 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
24 #include <net/genetlink.h>
25 #include <linux/nfc.h>
26 #include <linux/slab.h>
31 static const struct genl_multicast_group nfc_genl_mcgrps[] = {
32 { .name = NFC_GENL_MCAST_EVENT_NAME, },
35 static struct genl_family nfc_genl_family = {
36 .id = GENL_ID_GENERATE,
38 .name = NFC_GENL_NAME,
39 .version = NFC_GENL_VERSION,
40 .maxattr = NFC_ATTR_MAX,
43 static const struct nla_policy nfc_genl_policy[NFC_ATTR_MAX + 1] = {
44 [NFC_ATTR_DEVICE_INDEX] = { .type = NLA_U32 },
45 [NFC_ATTR_DEVICE_NAME] = { .type = NLA_STRING,
46 .len = NFC_DEVICE_NAME_MAXSIZE },
47 [NFC_ATTR_PROTOCOLS] = { .type = NLA_U32 },
48 [NFC_ATTR_COMM_MODE] = { .type = NLA_U8 },
49 [NFC_ATTR_RF_MODE] = { .type = NLA_U8 },
50 [NFC_ATTR_DEVICE_POWERED] = { .type = NLA_U8 },
51 [NFC_ATTR_IM_PROTOCOLS] = { .type = NLA_U32 },
52 [NFC_ATTR_TM_PROTOCOLS] = { .type = NLA_U32 },
53 [NFC_ATTR_LLC_PARAM_LTO] = { .type = NLA_U8 },
54 [NFC_ATTR_LLC_PARAM_RW] = { .type = NLA_U8 },
55 [NFC_ATTR_LLC_PARAM_MIUX] = { .type = NLA_U16 },
56 [NFC_ATTR_LLC_SDP] = { .type = NLA_NESTED },
57 [NFC_ATTR_FIRMWARE_NAME] = { .type = NLA_STRING,
58 .len = NFC_FIRMWARE_NAME_MAXSIZE },
59 [NFC_ATTR_SE_APDU] = { .type = NLA_BINARY },
62 static const struct nla_policy nfc_sdp_genl_policy[NFC_SDP_ATTR_MAX + 1] = {
63 [NFC_SDP_ATTR_URI] = { .type = NLA_STRING },
64 [NFC_SDP_ATTR_SAP] = { .type = NLA_U8 },
67 static int nfc_genl_send_target(struct sk_buff *msg, struct nfc_target *target,
68 struct netlink_callback *cb, int flags)
72 hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
73 &nfc_genl_family, flags, NFC_CMD_GET_TARGET);
77 genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
79 if (nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target->idx) ||
80 nla_put_u32(msg, NFC_ATTR_PROTOCOLS, target->supported_protocols) ||
81 nla_put_u16(msg, NFC_ATTR_TARGET_SENS_RES, target->sens_res) ||
82 nla_put_u8(msg, NFC_ATTR_TARGET_SEL_RES, target->sel_res))
84 if (target->nfcid1_len > 0 &&
85 nla_put(msg, NFC_ATTR_TARGET_NFCID1, target->nfcid1_len,
88 if (target->sensb_res_len > 0 &&
89 nla_put(msg, NFC_ATTR_TARGET_SENSB_RES, target->sensb_res_len,
92 if (target->sensf_res_len > 0 &&
93 nla_put(msg, NFC_ATTR_TARGET_SENSF_RES, target->sensf_res_len,
97 if (target->is_iso15693) {
98 if (nla_put_u8(msg, NFC_ATTR_TARGET_ISO15693_DSFID,
99 target->iso15693_dsfid) ||
100 nla_put(msg, NFC_ATTR_TARGET_ISO15693_UID,
101 sizeof(target->iso15693_uid), target->iso15693_uid))
102 goto nla_put_failure;
105 genlmsg_end(msg, hdr);
109 genlmsg_cancel(msg, hdr);
113 static struct nfc_dev *__get_device_from_cb(struct netlink_callback *cb)
119 rc = nlmsg_parse(cb->nlh, GENL_HDRLEN + nfc_genl_family.hdrsize,
120 nfc_genl_family.attrbuf,
121 nfc_genl_family.maxattr,
126 if (!nfc_genl_family.attrbuf[NFC_ATTR_DEVICE_INDEX])
127 return ERR_PTR(-EINVAL);
129 idx = nla_get_u32(nfc_genl_family.attrbuf[NFC_ATTR_DEVICE_INDEX]);
131 dev = nfc_get_device(idx);
133 return ERR_PTR(-ENODEV);
138 static int nfc_genl_dump_targets(struct sk_buff *skb,
139 struct netlink_callback *cb)
142 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
146 dev = __get_device_from_cb(cb);
150 cb->args[1] = (long) dev;
153 device_lock(&dev->dev);
155 cb->seq = dev->targets_generation;
157 while (i < dev->n_targets) {
158 rc = nfc_genl_send_target(skb, &dev->targets[i], cb,
166 device_unlock(&dev->dev);
173 static int nfc_genl_dump_targets_done(struct netlink_callback *cb)
175 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
183 int nfc_genl_targets_found(struct nfc_dev *dev)
188 dev->genl_data.poll_req_portid = 0;
190 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
194 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
195 NFC_EVENT_TARGETS_FOUND);
199 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
200 goto nla_put_failure;
202 genlmsg_end(msg, hdr);
204 return genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_ATOMIC);
207 genlmsg_cancel(msg, hdr);
213 int nfc_genl_target_lost(struct nfc_dev *dev, u32 target_idx)
218 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
222 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
223 NFC_EVENT_TARGET_LOST);
227 if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
228 nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
229 goto nla_put_failure;
231 genlmsg_end(msg, hdr);
233 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
238 genlmsg_cancel(msg, hdr);
244 int nfc_genl_tm_activated(struct nfc_dev *dev, u32 protocol)
249 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
253 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
254 NFC_EVENT_TM_ACTIVATED);
258 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
259 goto nla_put_failure;
260 if (nla_put_u32(msg, NFC_ATTR_TM_PROTOCOLS, protocol))
261 goto nla_put_failure;
263 genlmsg_end(msg, hdr);
265 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
270 genlmsg_cancel(msg, hdr);
276 int nfc_genl_tm_deactivated(struct nfc_dev *dev)
281 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
285 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
286 NFC_EVENT_TM_DEACTIVATED);
290 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
291 goto nla_put_failure;
293 genlmsg_end(msg, hdr);
295 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
300 genlmsg_cancel(msg, hdr);
306 int nfc_genl_device_added(struct nfc_dev *dev)
311 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
315 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
316 NFC_EVENT_DEVICE_ADDED);
320 if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
321 nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
322 nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
323 nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up))
324 goto nla_put_failure;
326 genlmsg_end(msg, hdr);
328 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
333 genlmsg_cancel(msg, hdr);
339 int nfc_genl_device_removed(struct nfc_dev *dev)
344 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
348 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
349 NFC_EVENT_DEVICE_REMOVED);
353 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
354 goto nla_put_failure;
356 genlmsg_end(msg, hdr);
358 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
363 genlmsg_cancel(msg, hdr);
369 int nfc_genl_llc_send_sdres(struct nfc_dev *dev, struct hlist_head *sdres_list)
372 struct nlattr *sdp_attr, *uri_attr;
373 struct nfc_llcp_sdp_tlv *sdres;
374 struct hlist_node *n;
379 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
383 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
384 NFC_EVENT_LLC_SDRES);
388 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
389 goto nla_put_failure;
391 sdp_attr = nla_nest_start(msg, NFC_ATTR_LLC_SDP);
392 if (sdp_attr == NULL) {
394 goto nla_put_failure;
398 hlist_for_each_entry_safe(sdres, n, sdres_list, node) {
399 pr_debug("uri: %s, sap: %d\n", sdres->uri, sdres->sap);
401 uri_attr = nla_nest_start(msg, i++);
402 if (uri_attr == NULL) {
404 goto nla_put_failure;
407 if (nla_put_u8(msg, NFC_SDP_ATTR_SAP, sdres->sap))
408 goto nla_put_failure;
410 if (nla_put_string(msg, NFC_SDP_ATTR_URI, sdres->uri))
411 goto nla_put_failure;
413 nla_nest_end(msg, uri_attr);
415 hlist_del(&sdres->node);
417 nfc_llcp_free_sdp_tlv(sdres);
420 nla_nest_end(msg, sdp_attr);
422 genlmsg_end(msg, hdr);
424 return genlmsg_multicast(&nfc_genl_family, msg, 0, 0, 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, 0, GFP_KERNEL);
463 genlmsg_cancel(msg, hdr);
469 int nfc_genl_se_removed(struct nfc_dev *dev, u32 se_idx)
474 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
478 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
479 NFC_EVENT_SE_REMOVED);
483 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
484 nla_put_u32(msg, NFC_ATTR_SE_INDEX, se_idx))
485 goto nla_put_failure;
487 genlmsg_end(msg, hdr);
489 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
494 genlmsg_cancel(msg, hdr);
500 static int nfc_genl_send_device(struct sk_buff *msg, struct nfc_dev *dev,
502 struct netlink_callback *cb,
507 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags,
513 genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
515 if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
516 nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
517 nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
518 nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up) ||
519 nla_put_u8(msg, NFC_ATTR_RF_MODE, dev->rf_mode))
520 goto nla_put_failure;
522 genlmsg_end(msg, hdr);
526 genlmsg_cancel(msg, hdr);
530 static int nfc_genl_dump_devices(struct sk_buff *skb,
531 struct netlink_callback *cb)
533 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
534 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
535 bool first_call = false;
539 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
542 cb->args[0] = (long) iter;
545 mutex_lock(&nfc_devlist_mutex);
547 cb->seq = nfc_devlist_generation;
550 nfc_device_iter_init(iter);
551 dev = nfc_device_iter_next(iter);
557 rc = nfc_genl_send_device(skb, dev, NETLINK_CB(cb->skb).portid,
558 cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
562 dev = nfc_device_iter_next(iter);
565 mutex_unlock(&nfc_devlist_mutex);
567 cb->args[1] = (long) dev;
572 static int nfc_genl_dump_devices_done(struct netlink_callback *cb)
574 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
576 nfc_device_iter_exit(iter);
582 int nfc_genl_dep_link_up_event(struct nfc_dev *dev, u32 target_idx,
583 u8 comm_mode, u8 rf_mode)
588 pr_debug("DEP link is up\n");
590 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
594 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, NFC_CMD_DEP_LINK_UP);
598 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
599 goto nla_put_failure;
600 if (rf_mode == NFC_RF_INITIATOR &&
601 nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
602 goto nla_put_failure;
603 if (nla_put_u8(msg, NFC_ATTR_COMM_MODE, comm_mode) ||
604 nla_put_u8(msg, NFC_ATTR_RF_MODE, rf_mode))
605 goto nla_put_failure;
607 genlmsg_end(msg, hdr);
609 dev->dep_link_up = true;
611 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_ATOMIC);
616 genlmsg_cancel(msg, hdr);
622 int nfc_genl_dep_link_down_event(struct nfc_dev *dev)
627 pr_debug("DEP link is down\n");
629 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
633 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
634 NFC_CMD_DEP_LINK_DOWN);
638 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
639 goto nla_put_failure;
641 genlmsg_end(msg, hdr);
643 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_ATOMIC);
648 genlmsg_cancel(msg, hdr);
654 static int nfc_genl_get_device(struct sk_buff *skb, struct genl_info *info)
661 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
664 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
666 dev = nfc_get_device(idx);
670 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
676 rc = nfc_genl_send_device(msg, dev, info->snd_portid, info->snd_seq,
683 return genlmsg_reply(msg, info);
692 static int nfc_genl_dev_up(struct sk_buff *skb, struct genl_info *info)
698 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
701 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
703 dev = nfc_get_device(idx);
707 rc = nfc_dev_up(dev);
713 static int nfc_genl_dev_down(struct sk_buff *skb, struct genl_info *info)
719 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
722 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
724 dev = nfc_get_device(idx);
728 rc = nfc_dev_down(dev);
734 static int nfc_genl_start_poll(struct sk_buff *skb, struct genl_info *info)
739 u32 im_protocols = 0, tm_protocols = 0;
741 pr_debug("Poll start\n");
743 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
744 ((!info->attrs[NFC_ATTR_IM_PROTOCOLS] &&
745 !info->attrs[NFC_ATTR_PROTOCOLS]) &&
746 !info->attrs[NFC_ATTR_TM_PROTOCOLS]))
749 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
751 if (info->attrs[NFC_ATTR_TM_PROTOCOLS])
752 tm_protocols = nla_get_u32(info->attrs[NFC_ATTR_TM_PROTOCOLS]);
754 if (info->attrs[NFC_ATTR_IM_PROTOCOLS])
755 im_protocols = nla_get_u32(info->attrs[NFC_ATTR_IM_PROTOCOLS]);
756 else if (info->attrs[NFC_ATTR_PROTOCOLS])
757 im_protocols = nla_get_u32(info->attrs[NFC_ATTR_PROTOCOLS]);
759 dev = nfc_get_device(idx);
763 mutex_lock(&dev->genl_data.genl_data_mutex);
765 rc = nfc_start_poll(dev, im_protocols, tm_protocols);
767 dev->genl_data.poll_req_portid = info->snd_portid;
769 mutex_unlock(&dev->genl_data.genl_data_mutex);
775 static int nfc_genl_stop_poll(struct sk_buff *skb, struct genl_info *info)
781 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
784 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
786 dev = nfc_get_device(idx);
790 device_lock(&dev->dev);
793 device_unlock(&dev->dev);
797 device_unlock(&dev->dev);
799 mutex_lock(&dev->genl_data.genl_data_mutex);
801 if (dev->genl_data.poll_req_portid != info->snd_portid) {
806 rc = nfc_stop_poll(dev);
807 dev->genl_data.poll_req_portid = 0;
810 mutex_unlock(&dev->genl_data.genl_data_mutex);
815 static int nfc_genl_activate_target(struct sk_buff *skb, struct genl_info *info)
818 u32 device_idx, target_idx, protocol;
821 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
824 device_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
826 dev = nfc_get_device(device_idx);
830 target_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]);
831 protocol = nla_get_u32(info->attrs[NFC_ATTR_PROTOCOLS]);
833 nfc_deactivate_target(dev, target_idx);
834 rc = nfc_activate_target(dev, target_idx, protocol);
840 static int nfc_genl_dep_link_up(struct sk_buff *skb, struct genl_info *info)
847 pr_debug("DEP link up\n");
849 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
850 !info->attrs[NFC_ATTR_COMM_MODE])
853 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
854 if (!info->attrs[NFC_ATTR_TARGET_INDEX])
855 tgt_idx = NFC_TARGET_IDX_ANY;
857 tgt_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]);
859 comm = nla_get_u8(info->attrs[NFC_ATTR_COMM_MODE]);
861 if (comm != NFC_COMM_ACTIVE && comm != NFC_COMM_PASSIVE)
864 dev = nfc_get_device(idx);
868 rc = nfc_dep_link_up(dev, tgt_idx, comm);
875 static int nfc_genl_dep_link_down(struct sk_buff *skb, struct genl_info *info)
881 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
884 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
886 dev = nfc_get_device(idx);
890 rc = nfc_dep_link_down(dev);
896 static int nfc_genl_send_params(struct sk_buff *msg,
897 struct nfc_llcp_local *local,
902 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, 0,
903 NFC_CMD_LLC_GET_PARAMS);
907 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, local->dev->idx) ||
908 nla_put_u8(msg, NFC_ATTR_LLC_PARAM_LTO, local->lto) ||
909 nla_put_u8(msg, NFC_ATTR_LLC_PARAM_RW, local->rw) ||
910 nla_put_u16(msg, NFC_ATTR_LLC_PARAM_MIUX, be16_to_cpu(local->miux)))
911 goto nla_put_failure;
913 genlmsg_end(msg, hdr);
918 genlmsg_cancel(msg, hdr);
922 static int nfc_genl_llc_get_params(struct sk_buff *skb, struct genl_info *info)
925 struct nfc_llcp_local *local;
927 struct sk_buff *msg = NULL;
930 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
933 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
935 dev = nfc_get_device(idx);
939 device_lock(&dev->dev);
941 local = nfc_llcp_find_local(dev);
947 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
953 rc = nfc_genl_send_params(msg, local, info->snd_portid, info->snd_seq);
956 device_unlock(&dev->dev);
967 return genlmsg_reply(msg, info);
970 static int nfc_genl_llc_set_params(struct sk_buff *skb, struct genl_info *info)
973 struct nfc_llcp_local *local;
979 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
980 (!info->attrs[NFC_ATTR_LLC_PARAM_LTO] &&
981 !info->attrs[NFC_ATTR_LLC_PARAM_RW] &&
982 !info->attrs[NFC_ATTR_LLC_PARAM_MIUX]))
985 if (info->attrs[NFC_ATTR_LLC_PARAM_RW]) {
986 rw = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_RW]);
988 if (rw > LLCP_MAX_RW)
992 if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX]) {
993 miux = nla_get_u16(info->attrs[NFC_ATTR_LLC_PARAM_MIUX]);
995 if (miux > LLCP_MAX_MIUX)
999 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1001 dev = nfc_get_device(idx);
1005 device_lock(&dev->dev);
1007 local = nfc_llcp_find_local(dev);
1009 nfc_put_device(dev);
1014 if (info->attrs[NFC_ATTR_LLC_PARAM_LTO]) {
1015 if (dev->dep_link_up) {
1020 local->lto = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_LTO]);
1023 if (info->attrs[NFC_ATTR_LLC_PARAM_RW])
1026 if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX])
1027 local->miux = cpu_to_be16(miux);
1030 device_unlock(&dev->dev);
1032 nfc_put_device(dev);
1037 static int nfc_genl_llc_sdreq(struct sk_buff *skb, struct genl_info *info)
1039 struct nfc_dev *dev;
1040 struct nfc_llcp_local *local;
1041 struct nlattr *attr, *sdp_attrs[NFC_SDP_ATTR_MAX+1];
1046 size_t uri_len, tlvs_len;
1047 struct hlist_head sdreq_list;
1048 struct nfc_llcp_sdp_tlv *sdreq;
1050 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1051 !info->attrs[NFC_ATTR_LLC_SDP])
1054 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1056 dev = nfc_get_device(idx);
1062 device_lock(&dev->dev);
1064 if (dev->dep_link_up == false) {
1069 local = nfc_llcp_find_local(dev);
1071 nfc_put_device(dev);
1076 INIT_HLIST_HEAD(&sdreq_list);
1080 nla_for_each_nested(attr, info->attrs[NFC_ATTR_LLC_SDP], rem) {
1081 rc = nla_parse_nested(sdp_attrs, NFC_SDP_ATTR_MAX, attr,
1082 nfc_sdp_genl_policy);
1089 if (!sdp_attrs[NFC_SDP_ATTR_URI])
1092 uri_len = nla_len(sdp_attrs[NFC_SDP_ATTR_URI]);
1096 uri = nla_data(sdp_attrs[NFC_SDP_ATTR_URI]);
1097 if (uri == NULL || *uri == 0)
1100 tid = local->sdreq_next_tid++;
1102 sdreq = nfc_llcp_build_sdreq_tlv(tid, uri, uri_len);
1103 if (sdreq == NULL) {
1108 tlvs_len += sdreq->tlv_len;
1110 hlist_add_head(&sdreq->node, &sdreq_list);
1113 if (hlist_empty(&sdreq_list)) {
1118 rc = nfc_llcp_send_snl_sdreq(local, &sdreq_list, tlvs_len);
1120 device_unlock(&dev->dev);
1122 nfc_put_device(dev);
1127 static int nfc_genl_fw_download(struct sk_buff *skb, struct genl_info *info)
1129 struct nfc_dev *dev;
1132 char firmware_name[NFC_FIRMWARE_NAME_MAXSIZE + 1];
1134 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
1137 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1139 dev = nfc_get_device(idx);
1143 nla_strlcpy(firmware_name, info->attrs[NFC_ATTR_FIRMWARE_NAME],
1144 sizeof(firmware_name));
1146 rc = nfc_fw_download(dev, firmware_name);
1148 nfc_put_device(dev);
1152 int nfc_genl_fw_download_done(struct nfc_dev *dev, const char *firmware_name,
1155 struct sk_buff *msg;
1158 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1162 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
1163 NFC_CMD_FW_DOWNLOAD);
1167 if (nla_put_string(msg, NFC_ATTR_FIRMWARE_NAME, firmware_name) ||
1168 nla_put_u32(msg, NFC_ATTR_FIRMWARE_DOWNLOAD_STATUS, result) ||
1169 nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
1170 goto nla_put_failure;
1172 genlmsg_end(msg, hdr);
1174 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
1179 genlmsg_cancel(msg, hdr);
1185 static int nfc_genl_enable_se(struct sk_buff *skb, struct genl_info *info)
1187 struct nfc_dev *dev;
1191 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1192 !info->attrs[NFC_ATTR_SE_INDEX])
1195 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1196 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1198 dev = nfc_get_device(idx);
1202 rc = nfc_enable_se(dev, se_idx);
1204 nfc_put_device(dev);
1208 static int nfc_genl_disable_se(struct sk_buff *skb, struct genl_info *info)
1210 struct nfc_dev *dev;
1214 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1215 !info->attrs[NFC_ATTR_SE_INDEX])
1218 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1219 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1221 dev = nfc_get_device(idx);
1225 rc = nfc_disable_se(dev, se_idx);
1227 nfc_put_device(dev);
1231 static int nfc_genl_send_se(struct sk_buff *msg, struct nfc_dev *dev,
1232 u32 portid, u32 seq,
1233 struct netlink_callback *cb,
1237 struct nfc_se *se, *n;
1239 list_for_each_entry_safe(se, n, &dev->secure_elements, list) {
1240 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags,
1243 goto nla_put_failure;
1246 genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
1248 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
1249 nla_put_u32(msg, NFC_ATTR_SE_INDEX, se->idx) ||
1250 nla_put_u8(msg, NFC_ATTR_SE_TYPE, se->type))
1251 goto nla_put_failure;
1253 genlmsg_end(msg, hdr);
1259 genlmsg_cancel(msg, hdr);
1263 static int nfc_genl_dump_ses(struct sk_buff *skb,
1264 struct netlink_callback *cb)
1266 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
1267 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
1268 bool first_call = false;
1272 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
1275 cb->args[0] = (long) iter;
1278 mutex_lock(&nfc_devlist_mutex);
1280 cb->seq = nfc_devlist_generation;
1283 nfc_device_iter_init(iter);
1284 dev = nfc_device_iter_next(iter);
1290 rc = nfc_genl_send_se(skb, dev, NETLINK_CB(cb->skb).portid,
1291 cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
1295 dev = nfc_device_iter_next(iter);
1298 mutex_unlock(&nfc_devlist_mutex);
1300 cb->args[1] = (long) dev;
1305 static int nfc_genl_dump_ses_done(struct netlink_callback *cb)
1307 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
1309 nfc_device_iter_exit(iter);
1315 static int nfc_se_io(struct nfc_dev *dev, u32 se_idx,
1316 u8 *apdu, size_t apdu_length,
1317 se_io_cb_t cb, void *cb_context)
1322 pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
1324 device_lock(&dev->dev);
1326 if (!device_is_registered(&dev->dev)) {
1336 if (!dev->ops->se_io) {
1341 se = nfc_find_se(dev, se_idx);
1347 if (se->state != NFC_SE_ENABLED) {
1352 rc = dev->ops->se_io(dev, se_idx, apdu,
1353 apdu_length, cb, cb_context);
1356 device_unlock(&dev->dev);
1365 static void se_io_cb(void *context, u8 *apdu, size_t apdu_len, int err)
1367 struct se_io_ctx *ctx = context;
1368 struct sk_buff *msg;
1371 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1377 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
1382 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, ctx->dev_idx) ||
1383 nla_put_u32(msg, NFC_ATTR_SE_INDEX, ctx->se_idx) ||
1384 nla_put(msg, NFC_ATTR_SE_APDU, apdu_len, apdu))
1385 goto nla_put_failure;
1387 genlmsg_end(msg, hdr);
1389 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
1396 genlmsg_cancel(msg, hdr);
1404 static int nfc_genl_se_io(struct sk_buff *skb, struct genl_info *info)
1406 struct nfc_dev *dev;
1407 struct se_io_ctx *ctx;
1408 u32 dev_idx, se_idx;
1412 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1413 !info->attrs[NFC_ATTR_SE_INDEX] ||
1414 !info->attrs[NFC_ATTR_SE_APDU])
1417 dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1418 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1420 dev = nfc_get_device(dev_idx);
1424 if (!dev->ops || !dev->ops->se_io)
1427 apdu_len = nla_len(info->attrs[NFC_ATTR_SE_APDU]);
1431 apdu = nla_data(info->attrs[NFC_ATTR_SE_APDU]);
1435 ctx = kzalloc(sizeof(struct se_io_ctx), GFP_KERNEL);
1439 ctx->dev_idx = dev_idx;
1440 ctx->se_idx = se_idx;
1442 return nfc_se_io(dev, se_idx, apdu, apdu_len, se_io_cb, ctx);
1445 static const struct genl_ops nfc_genl_ops[] = {
1447 .cmd = NFC_CMD_GET_DEVICE,
1448 .doit = nfc_genl_get_device,
1449 .dumpit = nfc_genl_dump_devices,
1450 .done = nfc_genl_dump_devices_done,
1451 .policy = nfc_genl_policy,
1454 .cmd = NFC_CMD_DEV_UP,
1455 .doit = nfc_genl_dev_up,
1456 .policy = nfc_genl_policy,
1459 .cmd = NFC_CMD_DEV_DOWN,
1460 .doit = nfc_genl_dev_down,
1461 .policy = nfc_genl_policy,
1464 .cmd = NFC_CMD_START_POLL,
1465 .doit = nfc_genl_start_poll,
1466 .policy = nfc_genl_policy,
1469 .cmd = NFC_CMD_STOP_POLL,
1470 .doit = nfc_genl_stop_poll,
1471 .policy = nfc_genl_policy,
1474 .cmd = NFC_CMD_DEP_LINK_UP,
1475 .doit = nfc_genl_dep_link_up,
1476 .policy = nfc_genl_policy,
1479 .cmd = NFC_CMD_DEP_LINK_DOWN,
1480 .doit = nfc_genl_dep_link_down,
1481 .policy = nfc_genl_policy,
1484 .cmd = NFC_CMD_GET_TARGET,
1485 .dumpit = nfc_genl_dump_targets,
1486 .done = nfc_genl_dump_targets_done,
1487 .policy = nfc_genl_policy,
1490 .cmd = NFC_CMD_LLC_GET_PARAMS,
1491 .doit = nfc_genl_llc_get_params,
1492 .policy = nfc_genl_policy,
1495 .cmd = NFC_CMD_LLC_SET_PARAMS,
1496 .doit = nfc_genl_llc_set_params,
1497 .policy = nfc_genl_policy,
1500 .cmd = NFC_CMD_LLC_SDREQ,
1501 .doit = nfc_genl_llc_sdreq,
1502 .policy = nfc_genl_policy,
1505 .cmd = NFC_CMD_FW_DOWNLOAD,
1506 .doit = nfc_genl_fw_download,
1507 .policy = nfc_genl_policy,
1510 .cmd = NFC_CMD_ENABLE_SE,
1511 .doit = nfc_genl_enable_se,
1512 .policy = nfc_genl_policy,
1515 .cmd = NFC_CMD_DISABLE_SE,
1516 .doit = nfc_genl_disable_se,
1517 .policy = nfc_genl_policy,
1520 .cmd = NFC_CMD_GET_SE,
1521 .dumpit = nfc_genl_dump_ses,
1522 .done = nfc_genl_dump_ses_done,
1523 .policy = nfc_genl_policy,
1526 .cmd = NFC_CMD_SE_IO,
1527 .doit = nfc_genl_se_io,
1528 .policy = nfc_genl_policy,
1531 .cmd = NFC_CMD_ACTIVATE_TARGET,
1532 .doit = nfc_genl_activate_target,
1533 .policy = nfc_genl_policy,
1538 struct urelease_work {
1539 struct work_struct w;
1543 static void nfc_urelease_event_work(struct work_struct *work)
1545 struct urelease_work *w = container_of(work, struct urelease_work, w);
1546 struct class_dev_iter iter;
1547 struct nfc_dev *dev;
1549 pr_debug("portid %d\n", w->portid);
1551 mutex_lock(&nfc_devlist_mutex);
1553 nfc_device_iter_init(&iter);
1554 dev = nfc_device_iter_next(&iter);
1557 mutex_lock(&dev->genl_data.genl_data_mutex);
1559 if (dev->genl_data.poll_req_portid == w->portid) {
1561 dev->genl_data.poll_req_portid = 0;
1564 mutex_unlock(&dev->genl_data.genl_data_mutex);
1566 dev = nfc_device_iter_next(&iter);
1569 nfc_device_iter_exit(&iter);
1571 mutex_unlock(&nfc_devlist_mutex);
1576 static int nfc_genl_rcv_nl_event(struct notifier_block *this,
1577 unsigned long event, void *ptr)
1579 struct netlink_notify *n = ptr;
1580 struct urelease_work *w;
1582 if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC)
1585 pr_debug("NETLINK_URELEASE event from id %d\n", n->portid);
1587 w = kmalloc(sizeof(*w), GFP_ATOMIC);
1589 INIT_WORK((struct work_struct *) w, nfc_urelease_event_work);
1590 w->portid = n->portid;
1591 schedule_work((struct work_struct *) w);
1598 void nfc_genl_data_init(struct nfc_genl_data *genl_data)
1600 genl_data->poll_req_portid = 0;
1601 mutex_init(&genl_data->genl_data_mutex);
1604 void nfc_genl_data_exit(struct nfc_genl_data *genl_data)
1606 mutex_destroy(&genl_data->genl_data_mutex);
1609 static struct notifier_block nl_notifier = {
1610 .notifier_call = nfc_genl_rcv_nl_event,
1614 * nfc_genl_init() - Initialize netlink interface
1616 * This initialization function registers the nfc netlink family.
1618 int __init nfc_genl_init(void)
1622 rc = genl_register_family_with_ops_groups(&nfc_genl_family,
1628 netlink_register_notifier(&nl_notifier);
1634 * nfc_genl_exit() - Deinitialize netlink interface
1636 * This exit function unregisters the nfc netlink family.
1638 void nfc_genl_exit(void)
1640 netlink_unregister_notifier(&nl_notifier);
1641 genl_unregister_family(&nfc_genl_family);