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 return genlmsg_end(msg
, hdr
);
100 genlmsg_cancel(msg
, hdr
);
104 static struct nfc_dev
*__get_device_from_cb(struct netlink_callback
*cb
)
110 rc
= nlmsg_parse(cb
->nlh
, GENL_HDRLEN
+ nfc_genl_family
.hdrsize
,
111 nfc_genl_family
.attrbuf
,
112 nfc_genl_family
.maxattr
,
117 if (!nfc_genl_family
.attrbuf
[NFC_ATTR_DEVICE_INDEX
])
118 return ERR_PTR(-EINVAL
);
120 idx
= nla_get_u32(nfc_genl_family
.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
);
198 genlmsg_cancel(msg
, hdr
);
204 int nfc_genl_target_lost(struct nfc_dev
*dev
, u32 target_idx
)
209 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
213 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
214 NFC_EVENT_TARGET_LOST
);
218 if (nla_put_string(msg
, NFC_ATTR_DEVICE_NAME
, nfc_device_name(dev
)) ||
219 nla_put_u32(msg
, NFC_ATTR_TARGET_INDEX
, target_idx
))
220 goto nla_put_failure
;
222 genlmsg_end(msg
, hdr
);
224 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
229 genlmsg_cancel(msg
, hdr
);
235 int nfc_genl_tm_activated(struct nfc_dev
*dev
, u32 protocol
)
240 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
244 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
245 NFC_EVENT_TM_ACTIVATED
);
249 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
250 goto nla_put_failure
;
251 if (nla_put_u32(msg
, NFC_ATTR_TM_PROTOCOLS
, protocol
))
252 goto nla_put_failure
;
254 genlmsg_end(msg
, hdr
);
256 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
261 genlmsg_cancel(msg
, hdr
);
267 int nfc_genl_tm_deactivated(struct nfc_dev
*dev
)
272 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
276 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
277 NFC_EVENT_TM_DEACTIVATED
);
281 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
282 goto nla_put_failure
;
284 genlmsg_end(msg
, hdr
);
286 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
291 genlmsg_cancel(msg
, hdr
);
297 int nfc_genl_device_added(struct nfc_dev
*dev
)
302 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
306 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
307 NFC_EVENT_DEVICE_ADDED
);
311 if (nla_put_string(msg
, NFC_ATTR_DEVICE_NAME
, nfc_device_name(dev
)) ||
312 nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
313 nla_put_u32(msg
, NFC_ATTR_PROTOCOLS
, dev
->supported_protocols
) ||
314 nla_put_u8(msg
, NFC_ATTR_DEVICE_POWERED
, dev
->dev_up
))
315 goto nla_put_failure
;
317 genlmsg_end(msg
, hdr
);
319 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
324 genlmsg_cancel(msg
, hdr
);
330 int nfc_genl_device_removed(struct nfc_dev
*dev
)
335 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
339 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
340 NFC_EVENT_DEVICE_REMOVED
);
344 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
345 goto nla_put_failure
;
347 genlmsg_end(msg
, hdr
);
349 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
354 genlmsg_cancel(msg
, hdr
);
360 int nfc_genl_llc_send_sdres(struct nfc_dev
*dev
, struct hlist_head
*sdres_list
)
363 struct nlattr
*sdp_attr
, *uri_attr
;
364 struct nfc_llcp_sdp_tlv
*sdres
;
365 struct hlist_node
*n
;
370 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
374 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
375 NFC_EVENT_LLC_SDRES
);
379 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
380 goto nla_put_failure
;
382 sdp_attr
= nla_nest_start(msg
, NFC_ATTR_LLC_SDP
);
383 if (sdp_attr
== NULL
) {
385 goto nla_put_failure
;
389 hlist_for_each_entry_safe(sdres
, n
, sdres_list
, node
) {
390 pr_debug("uri: %s, sap: %d\n", sdres
->uri
, sdres
->sap
);
392 uri_attr
= nla_nest_start(msg
, i
++);
393 if (uri_attr
== NULL
) {
395 goto nla_put_failure
;
398 if (nla_put_u8(msg
, NFC_SDP_ATTR_SAP
, sdres
->sap
))
399 goto nla_put_failure
;
401 if (nla_put_string(msg
, NFC_SDP_ATTR_URI
, sdres
->uri
))
402 goto nla_put_failure
;
404 nla_nest_end(msg
, uri_attr
);
406 hlist_del(&sdres
->node
);
408 nfc_llcp_free_sdp_tlv(sdres
);
411 nla_nest_end(msg
, sdp_attr
);
413 genlmsg_end(msg
, hdr
);
415 return genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_ATOMIC
);
418 genlmsg_cancel(msg
, hdr
);
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
);
454 genlmsg_cancel(msg
, hdr
);
460 int nfc_genl_se_removed(struct nfc_dev
*dev
, u32 se_idx
)
465 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
469 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
470 NFC_EVENT_SE_REMOVED
);
474 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
475 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se_idx
))
476 goto nla_put_failure
;
478 genlmsg_end(msg
, hdr
);
480 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
485 genlmsg_cancel(msg
, hdr
);
491 static int nfc_genl_send_device(struct sk_buff
*msg
, struct nfc_dev
*dev
,
493 struct netlink_callback
*cb
,
498 hdr
= genlmsg_put(msg
, portid
, seq
, &nfc_genl_family
, flags
,
504 genl_dump_check_consistent(cb
, hdr
, &nfc_genl_family
);
506 if (nla_put_string(msg
, NFC_ATTR_DEVICE_NAME
, nfc_device_name(dev
)) ||
507 nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
508 nla_put_u32(msg
, NFC_ATTR_PROTOCOLS
, dev
->supported_protocols
) ||
509 nla_put_u8(msg
, NFC_ATTR_DEVICE_POWERED
, dev
->dev_up
) ||
510 nla_put_u8(msg
, NFC_ATTR_RF_MODE
, dev
->rf_mode
))
511 goto nla_put_failure
;
513 return genlmsg_end(msg
, hdr
);
516 genlmsg_cancel(msg
, hdr
);
520 static int nfc_genl_dump_devices(struct sk_buff
*skb
,
521 struct netlink_callback
*cb
)
523 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
524 struct nfc_dev
*dev
= (struct nfc_dev
*) cb
->args
[1];
525 bool first_call
= false;
529 iter
= kmalloc(sizeof(struct class_dev_iter
), GFP_KERNEL
);
532 cb
->args
[0] = (long) iter
;
535 mutex_lock(&nfc_devlist_mutex
);
537 cb
->seq
= nfc_devlist_generation
;
540 nfc_device_iter_init(iter
);
541 dev
= nfc_device_iter_next(iter
);
547 rc
= nfc_genl_send_device(skb
, dev
, NETLINK_CB(cb
->skb
).portid
,
548 cb
->nlh
->nlmsg_seq
, cb
, NLM_F_MULTI
);
552 dev
= nfc_device_iter_next(iter
);
555 mutex_unlock(&nfc_devlist_mutex
);
557 cb
->args
[1] = (long) dev
;
562 static int nfc_genl_dump_devices_done(struct netlink_callback
*cb
)
564 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
566 nfc_device_iter_exit(iter
);
572 int nfc_genl_dep_link_up_event(struct nfc_dev
*dev
, u32 target_idx
,
573 u8 comm_mode
, u8 rf_mode
)
578 pr_debug("DEP link is up\n");
580 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
584 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0, NFC_CMD_DEP_LINK_UP
);
588 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
589 goto nla_put_failure
;
590 if (rf_mode
== NFC_RF_INITIATOR
&&
591 nla_put_u32(msg
, NFC_ATTR_TARGET_INDEX
, target_idx
))
592 goto nla_put_failure
;
593 if (nla_put_u8(msg
, NFC_ATTR_COMM_MODE
, comm_mode
) ||
594 nla_put_u8(msg
, NFC_ATTR_RF_MODE
, rf_mode
))
595 goto nla_put_failure
;
597 genlmsg_end(msg
, hdr
);
599 dev
->dep_link_up
= true;
601 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_ATOMIC
);
606 genlmsg_cancel(msg
, hdr
);
612 int nfc_genl_dep_link_down_event(struct nfc_dev
*dev
)
617 pr_debug("DEP link is down\n");
619 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
623 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
624 NFC_CMD_DEP_LINK_DOWN
);
628 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
629 goto nla_put_failure
;
631 genlmsg_end(msg
, hdr
);
633 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_ATOMIC
);
638 genlmsg_cancel(msg
, hdr
);
644 static int nfc_genl_get_device(struct sk_buff
*skb
, struct genl_info
*info
)
651 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
654 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
656 dev
= nfc_get_device(idx
);
660 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
666 rc
= nfc_genl_send_device(msg
, dev
, info
->snd_portid
, info
->snd_seq
,
673 return genlmsg_reply(msg
, info
);
682 static int nfc_genl_dev_up(struct sk_buff
*skb
, struct genl_info
*info
)
688 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
691 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
693 dev
= nfc_get_device(idx
);
697 rc
= nfc_dev_up(dev
);
703 static int nfc_genl_dev_down(struct sk_buff
*skb
, struct genl_info
*info
)
709 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
712 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
714 dev
= nfc_get_device(idx
);
718 rc
= nfc_dev_down(dev
);
724 static int nfc_genl_start_poll(struct sk_buff
*skb
, struct genl_info
*info
)
729 u32 im_protocols
= 0, tm_protocols
= 0;
731 pr_debug("Poll start\n");
733 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
734 ((!info
->attrs
[NFC_ATTR_IM_PROTOCOLS
] &&
735 !info
->attrs
[NFC_ATTR_PROTOCOLS
]) &&
736 !info
->attrs
[NFC_ATTR_TM_PROTOCOLS
]))
739 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
741 if (info
->attrs
[NFC_ATTR_TM_PROTOCOLS
])
742 tm_protocols
= nla_get_u32(info
->attrs
[NFC_ATTR_TM_PROTOCOLS
]);
744 if (info
->attrs
[NFC_ATTR_IM_PROTOCOLS
])
745 im_protocols
= nla_get_u32(info
->attrs
[NFC_ATTR_IM_PROTOCOLS
]);
746 else if (info
->attrs
[NFC_ATTR_PROTOCOLS
])
747 im_protocols
= nla_get_u32(info
->attrs
[NFC_ATTR_PROTOCOLS
]);
749 dev
= nfc_get_device(idx
);
753 mutex_lock(&dev
->genl_data
.genl_data_mutex
);
755 rc
= nfc_start_poll(dev
, im_protocols
, tm_protocols
);
757 dev
->genl_data
.poll_req_portid
= info
->snd_portid
;
759 mutex_unlock(&dev
->genl_data
.genl_data_mutex
);
765 static int nfc_genl_stop_poll(struct sk_buff
*skb
, struct genl_info
*info
)
771 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
774 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
776 dev
= nfc_get_device(idx
);
780 device_lock(&dev
->dev
);
783 device_unlock(&dev
->dev
);
787 device_unlock(&dev
->dev
);
789 mutex_lock(&dev
->genl_data
.genl_data_mutex
);
791 if (dev
->genl_data
.poll_req_portid
!= info
->snd_portid
) {
796 rc
= nfc_stop_poll(dev
);
797 dev
->genl_data
.poll_req_portid
= 0;
800 mutex_unlock(&dev
->genl_data
.genl_data_mutex
);
805 static int nfc_genl_dep_link_up(struct sk_buff
*skb
, struct genl_info
*info
)
812 pr_debug("DEP link up\n");
814 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
815 !info
->attrs
[NFC_ATTR_COMM_MODE
])
818 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
819 if (!info
->attrs
[NFC_ATTR_TARGET_INDEX
])
820 tgt_idx
= NFC_TARGET_IDX_ANY
;
822 tgt_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_TARGET_INDEX
]);
824 comm
= nla_get_u8(info
->attrs
[NFC_ATTR_COMM_MODE
]);
826 if (comm
!= NFC_COMM_ACTIVE
&& comm
!= NFC_COMM_PASSIVE
)
829 dev
= nfc_get_device(idx
);
833 rc
= nfc_dep_link_up(dev
, tgt_idx
, comm
);
840 static int nfc_genl_dep_link_down(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 rc
= nfc_dep_link_down(dev
);
861 static int nfc_genl_send_params(struct sk_buff
*msg
,
862 struct nfc_llcp_local
*local
,
867 hdr
= genlmsg_put(msg
, portid
, seq
, &nfc_genl_family
, 0,
868 NFC_CMD_LLC_GET_PARAMS
);
872 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, local
->dev
->idx
) ||
873 nla_put_u8(msg
, NFC_ATTR_LLC_PARAM_LTO
, local
->lto
) ||
874 nla_put_u8(msg
, NFC_ATTR_LLC_PARAM_RW
, local
->rw
) ||
875 nla_put_u16(msg
, NFC_ATTR_LLC_PARAM_MIUX
, be16_to_cpu(local
->miux
)))
876 goto nla_put_failure
;
878 return genlmsg_end(msg
, hdr
);
882 genlmsg_cancel(msg
, hdr
);
886 static int nfc_genl_llc_get_params(struct sk_buff
*skb
, struct genl_info
*info
)
889 struct nfc_llcp_local
*local
;
891 struct sk_buff
*msg
= NULL
;
894 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
897 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
899 dev
= nfc_get_device(idx
);
903 device_lock(&dev
->dev
);
905 local
= nfc_llcp_find_local(dev
);
911 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
917 rc
= nfc_genl_send_params(msg
, local
, info
->snd_portid
, info
->snd_seq
);
920 device_unlock(&dev
->dev
);
931 return genlmsg_reply(msg
, info
);
934 static int nfc_genl_llc_set_params(struct sk_buff
*skb
, struct genl_info
*info
)
937 struct nfc_llcp_local
*local
;
943 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
944 (!info
->attrs
[NFC_ATTR_LLC_PARAM_LTO
] &&
945 !info
->attrs
[NFC_ATTR_LLC_PARAM_RW
] &&
946 !info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
]))
949 if (info
->attrs
[NFC_ATTR_LLC_PARAM_RW
]) {
950 rw
= nla_get_u8(info
->attrs
[NFC_ATTR_LLC_PARAM_RW
]);
952 if (rw
> LLCP_MAX_RW
)
956 if (info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
]) {
957 miux
= nla_get_u16(info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
]);
959 if (miux
> LLCP_MAX_MIUX
)
963 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
965 dev
= nfc_get_device(idx
);
969 device_lock(&dev
->dev
);
971 local
= nfc_llcp_find_local(dev
);
978 if (info
->attrs
[NFC_ATTR_LLC_PARAM_LTO
]) {
979 if (dev
->dep_link_up
) {
984 local
->lto
= nla_get_u8(info
->attrs
[NFC_ATTR_LLC_PARAM_LTO
]);
987 if (info
->attrs
[NFC_ATTR_LLC_PARAM_RW
])
990 if (info
->attrs
[NFC_ATTR_LLC_PARAM_MIUX
])
991 local
->miux
= cpu_to_be16(miux
);
994 device_unlock(&dev
->dev
);
1001 static int nfc_genl_llc_sdreq(struct sk_buff
*skb
, struct genl_info
*info
)
1003 struct nfc_dev
*dev
;
1004 struct nfc_llcp_local
*local
;
1005 struct nlattr
*attr
, *sdp_attrs
[NFC_SDP_ATTR_MAX
+1];
1010 size_t uri_len
, tlvs_len
;
1011 struct hlist_head sdreq_list
;
1012 struct nfc_llcp_sdp_tlv
*sdreq
;
1014 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1015 !info
->attrs
[NFC_ATTR_LLC_SDP
])
1018 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1020 dev
= nfc_get_device(idx
);
1026 device_lock(&dev
->dev
);
1028 if (dev
->dep_link_up
== false) {
1033 local
= nfc_llcp_find_local(dev
);
1035 nfc_put_device(dev
);
1040 INIT_HLIST_HEAD(&sdreq_list
);
1044 nla_for_each_nested(attr
, info
->attrs
[NFC_ATTR_LLC_SDP
], rem
) {
1045 rc
= nla_parse_nested(sdp_attrs
, NFC_SDP_ATTR_MAX
, attr
,
1046 nfc_sdp_genl_policy
);
1053 if (!sdp_attrs
[NFC_SDP_ATTR_URI
])
1056 uri_len
= nla_len(sdp_attrs
[NFC_SDP_ATTR_URI
]);
1060 uri
= nla_data(sdp_attrs
[NFC_SDP_ATTR_URI
]);
1061 if (uri
== NULL
|| *uri
== 0)
1064 tid
= local
->sdreq_next_tid
++;
1066 sdreq
= nfc_llcp_build_sdreq_tlv(tid
, uri
, uri_len
);
1067 if (sdreq
== NULL
) {
1072 tlvs_len
+= sdreq
->tlv_len
;
1074 hlist_add_head(&sdreq
->node
, &sdreq_list
);
1077 if (hlist_empty(&sdreq_list
)) {
1082 rc
= nfc_llcp_send_snl_sdreq(local
, &sdreq_list
, tlvs_len
);
1084 device_unlock(&dev
->dev
);
1086 nfc_put_device(dev
);
1091 static int nfc_genl_fw_download(struct sk_buff
*skb
, struct genl_info
*info
)
1093 struct nfc_dev
*dev
;
1096 char firmware_name
[NFC_FIRMWARE_NAME_MAXSIZE
+ 1];
1098 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
])
1101 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1103 dev
= nfc_get_device(idx
);
1107 nla_strlcpy(firmware_name
, info
->attrs
[NFC_ATTR_FIRMWARE_NAME
],
1108 sizeof(firmware_name
));
1110 rc
= nfc_fw_download(dev
, firmware_name
);
1112 nfc_put_device(dev
);
1116 int nfc_genl_fw_download_done(struct nfc_dev
*dev
, const char *firmware_name
,
1119 struct sk_buff
*msg
;
1122 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1126 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
1127 NFC_CMD_FW_DOWNLOAD
);
1131 if (nla_put_string(msg
, NFC_ATTR_FIRMWARE_NAME
, firmware_name
) ||
1132 nla_put_u32(msg
, NFC_ATTR_FIRMWARE_DOWNLOAD_STATUS
, result
) ||
1133 nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
))
1134 goto nla_put_failure
;
1136 genlmsg_end(msg
, hdr
);
1138 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
1143 genlmsg_cancel(msg
, hdr
);
1149 static int nfc_genl_enable_se(struct sk_buff
*skb
, struct genl_info
*info
)
1151 struct nfc_dev
*dev
;
1155 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1156 !info
->attrs
[NFC_ATTR_SE_INDEX
])
1159 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1160 se_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_SE_INDEX
]);
1162 dev
= nfc_get_device(idx
);
1166 rc
= nfc_enable_se(dev
, se_idx
);
1168 nfc_put_device(dev
);
1172 static int nfc_genl_disable_se(struct sk_buff
*skb
, struct genl_info
*info
)
1174 struct nfc_dev
*dev
;
1178 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1179 !info
->attrs
[NFC_ATTR_SE_INDEX
])
1182 idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1183 se_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_SE_INDEX
]);
1185 dev
= nfc_get_device(idx
);
1189 rc
= nfc_disable_se(dev
, se_idx
);
1191 nfc_put_device(dev
);
1195 static int nfc_genl_send_se(struct sk_buff
*msg
, struct nfc_dev
*dev
,
1196 u32 portid
, u32 seq
,
1197 struct netlink_callback
*cb
,
1201 struct nfc_se
*se
, *n
;
1203 list_for_each_entry_safe(se
, n
, &dev
->secure_elements
, list
) {
1204 hdr
= genlmsg_put(msg
, portid
, seq
, &nfc_genl_family
, flags
,
1207 goto nla_put_failure
;
1210 genl_dump_check_consistent(cb
, hdr
, &nfc_genl_family
);
1212 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, dev
->idx
) ||
1213 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, se
->idx
) ||
1214 nla_put_u8(msg
, NFC_ATTR_SE_TYPE
, se
->type
))
1215 goto nla_put_failure
;
1217 if (genlmsg_end(msg
, hdr
) < 0)
1218 goto nla_put_failure
;
1224 genlmsg_cancel(msg
, hdr
);
1228 static int nfc_genl_dump_ses(struct sk_buff
*skb
,
1229 struct netlink_callback
*cb
)
1231 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
1232 struct nfc_dev
*dev
= (struct nfc_dev
*) cb
->args
[1];
1233 bool first_call
= false;
1237 iter
= kmalloc(sizeof(struct class_dev_iter
), GFP_KERNEL
);
1240 cb
->args
[0] = (long) iter
;
1243 mutex_lock(&nfc_devlist_mutex
);
1245 cb
->seq
= nfc_devlist_generation
;
1248 nfc_device_iter_init(iter
);
1249 dev
= nfc_device_iter_next(iter
);
1255 rc
= nfc_genl_send_se(skb
, dev
, NETLINK_CB(cb
->skb
).portid
,
1256 cb
->nlh
->nlmsg_seq
, cb
, NLM_F_MULTI
);
1260 dev
= nfc_device_iter_next(iter
);
1263 mutex_unlock(&nfc_devlist_mutex
);
1265 cb
->args
[1] = (long) dev
;
1270 static int nfc_genl_dump_ses_done(struct netlink_callback
*cb
)
1272 struct class_dev_iter
*iter
= (struct class_dev_iter
*) cb
->args
[0];
1274 nfc_device_iter_exit(iter
);
1285 static void se_io_cb(void *context
, u8
*apdu
, size_t apdu_len
, int err
)
1287 struct se_io_ctx
*ctx
= context
;
1288 struct sk_buff
*msg
;
1291 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1297 hdr
= genlmsg_put(msg
, 0, 0, &nfc_genl_family
, 0,
1302 if (nla_put_u32(msg
, NFC_ATTR_DEVICE_INDEX
, ctx
->dev_idx
) ||
1303 nla_put_u32(msg
, NFC_ATTR_SE_INDEX
, ctx
->se_idx
) ||
1304 nla_put(msg
, NFC_ATTR_SE_APDU
, apdu_len
, apdu
))
1305 goto nla_put_failure
;
1307 genlmsg_end(msg
, hdr
);
1309 genlmsg_multicast(&nfc_genl_family
, msg
, 0, 0, GFP_KERNEL
);
1316 genlmsg_cancel(msg
, hdr
);
1324 static int nfc_genl_se_io(struct sk_buff
*skb
, struct genl_info
*info
)
1326 struct nfc_dev
*dev
;
1327 struct se_io_ctx
*ctx
;
1328 u32 dev_idx
, se_idx
;
1332 if (!info
->attrs
[NFC_ATTR_DEVICE_INDEX
] ||
1333 !info
->attrs
[NFC_ATTR_SE_INDEX
] ||
1334 !info
->attrs
[NFC_ATTR_SE_APDU
])
1337 dev_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_DEVICE_INDEX
]);
1338 se_idx
= nla_get_u32(info
->attrs
[NFC_ATTR_SE_INDEX
]);
1340 dev
= nfc_get_device(dev_idx
);
1344 if (!dev
->ops
|| !dev
->ops
->se_io
)
1347 apdu_len
= nla_len(info
->attrs
[NFC_ATTR_SE_APDU
]);
1351 apdu
= nla_data(info
->attrs
[NFC_ATTR_SE_APDU
]);
1355 ctx
= kzalloc(sizeof(struct se_io_ctx
), GFP_KERNEL
);
1359 ctx
->dev_idx
= dev_idx
;
1360 ctx
->se_idx
= se_idx
;
1362 return dev
->ops
->se_io(dev
, se_idx
, apdu
, apdu_len
, se_io_cb
, ctx
);
1365 static const struct genl_ops nfc_genl_ops
[] = {
1367 .cmd
= NFC_CMD_GET_DEVICE
,
1368 .doit
= nfc_genl_get_device
,
1369 .dumpit
= nfc_genl_dump_devices
,
1370 .done
= nfc_genl_dump_devices_done
,
1371 .policy
= nfc_genl_policy
,
1374 .cmd
= NFC_CMD_DEV_UP
,
1375 .doit
= nfc_genl_dev_up
,
1376 .policy
= nfc_genl_policy
,
1379 .cmd
= NFC_CMD_DEV_DOWN
,
1380 .doit
= nfc_genl_dev_down
,
1381 .policy
= nfc_genl_policy
,
1384 .cmd
= NFC_CMD_START_POLL
,
1385 .doit
= nfc_genl_start_poll
,
1386 .policy
= nfc_genl_policy
,
1389 .cmd
= NFC_CMD_STOP_POLL
,
1390 .doit
= nfc_genl_stop_poll
,
1391 .policy
= nfc_genl_policy
,
1394 .cmd
= NFC_CMD_DEP_LINK_UP
,
1395 .doit
= nfc_genl_dep_link_up
,
1396 .policy
= nfc_genl_policy
,
1399 .cmd
= NFC_CMD_DEP_LINK_DOWN
,
1400 .doit
= nfc_genl_dep_link_down
,
1401 .policy
= nfc_genl_policy
,
1404 .cmd
= NFC_CMD_GET_TARGET
,
1405 .dumpit
= nfc_genl_dump_targets
,
1406 .done
= nfc_genl_dump_targets_done
,
1407 .policy
= nfc_genl_policy
,
1410 .cmd
= NFC_CMD_LLC_GET_PARAMS
,
1411 .doit
= nfc_genl_llc_get_params
,
1412 .policy
= nfc_genl_policy
,
1415 .cmd
= NFC_CMD_LLC_SET_PARAMS
,
1416 .doit
= nfc_genl_llc_set_params
,
1417 .policy
= nfc_genl_policy
,
1420 .cmd
= NFC_CMD_LLC_SDREQ
,
1421 .doit
= nfc_genl_llc_sdreq
,
1422 .policy
= nfc_genl_policy
,
1425 .cmd
= NFC_CMD_FW_DOWNLOAD
,
1426 .doit
= nfc_genl_fw_download
,
1427 .policy
= nfc_genl_policy
,
1430 .cmd
= NFC_CMD_ENABLE_SE
,
1431 .doit
= nfc_genl_enable_se
,
1432 .policy
= nfc_genl_policy
,
1435 .cmd
= NFC_CMD_DISABLE_SE
,
1436 .doit
= nfc_genl_disable_se
,
1437 .policy
= nfc_genl_policy
,
1440 .cmd
= NFC_CMD_GET_SE
,
1441 .dumpit
= nfc_genl_dump_ses
,
1442 .done
= nfc_genl_dump_ses_done
,
1443 .policy
= nfc_genl_policy
,
1446 .cmd
= NFC_CMD_SE_IO
,
1447 .doit
= nfc_genl_se_io
,
1448 .policy
= nfc_genl_policy
,
1453 struct urelease_work
{
1454 struct work_struct w
;
1458 static void nfc_urelease_event_work(struct work_struct
*work
)
1460 struct urelease_work
*w
= container_of(work
, struct urelease_work
, w
);
1461 struct class_dev_iter iter
;
1462 struct nfc_dev
*dev
;
1464 pr_debug("portid %d\n", w
->portid
);
1466 mutex_lock(&nfc_devlist_mutex
);
1468 nfc_device_iter_init(&iter
);
1469 dev
= nfc_device_iter_next(&iter
);
1472 mutex_lock(&dev
->genl_data
.genl_data_mutex
);
1474 if (dev
->genl_data
.poll_req_portid
== w
->portid
) {
1476 dev
->genl_data
.poll_req_portid
= 0;
1479 mutex_unlock(&dev
->genl_data
.genl_data_mutex
);
1481 dev
= nfc_device_iter_next(&iter
);
1484 nfc_device_iter_exit(&iter
);
1486 mutex_unlock(&nfc_devlist_mutex
);
1491 static int nfc_genl_rcv_nl_event(struct notifier_block
*this,
1492 unsigned long event
, void *ptr
)
1494 struct netlink_notify
*n
= ptr
;
1495 struct urelease_work
*w
;
1497 if (event
!= NETLINK_URELEASE
|| n
->protocol
!= NETLINK_GENERIC
)
1500 pr_debug("NETLINK_URELEASE event from id %d\n", n
->portid
);
1502 w
= kmalloc(sizeof(*w
), GFP_ATOMIC
);
1504 INIT_WORK((struct work_struct
*) w
, nfc_urelease_event_work
);
1505 w
->portid
= n
->portid
;
1506 schedule_work((struct work_struct
*) w
);
1513 void nfc_genl_data_init(struct nfc_genl_data
*genl_data
)
1515 genl_data
->poll_req_portid
= 0;
1516 mutex_init(&genl_data
->genl_data_mutex
);
1519 void nfc_genl_data_exit(struct nfc_genl_data
*genl_data
)
1521 mutex_destroy(&genl_data
->genl_data_mutex
);
1524 static struct notifier_block nl_notifier
= {
1525 .notifier_call
= nfc_genl_rcv_nl_event
,
1529 * nfc_genl_init() - Initialize netlink interface
1531 * This initialization function registers the nfc netlink family.
1533 int __init
nfc_genl_init(void)
1537 rc
= genl_register_family_with_ops_groups(&nfc_genl_family
,
1543 netlink_register_notifier(&nl_notifier
);
1549 * nfc_genl_exit() - Deinitialize netlink interface
1551 * This exit function unregisters the nfc netlink family.
1553 void nfc_genl_exit(void)
1555 netlink_unregister_notifier(&nl_notifier
);
1556 genl_unregister_family(&nfc_genl_family
);