[mirror_ubuntu-zesty-kernel.git] / net / nfc / netlink.c

/*
 * Copyright (C) 2011 Instituto Nokia de Tecnologia
 *
 * Authors:
 *    Lauro Ramos Venancio <lauro.venancio@openbossa.org>
 *    Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc.,
 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__

#include <net/genetlink.h>
#include <linux/nfc.h>
#include <linux/slab.h>

#include "nfc.h"

static struct genl_multicast_group nfc_genl_event_mcgrp = {
	.name = NFC_GENL_MCAST_EVENT_NAME,
};

static struct genl_family nfc_genl_family = {
	.id = GENL_ID_GENERATE,
	.hdrsize = 0,
	.name = NFC_GENL_NAME,
	.version = NFC_GENL_VERSION,
	.maxattr = NFC_ATTR_MAX,
};

static const struct nla_policy nfc_genl_policy[NFC_ATTR_MAX + 1] = {
	[NFC_ATTR_DEVICE_INDEX] = { .type = NLA_U32 },
	[NFC_ATTR_DEVICE_NAME] = { .type = NLA_STRING,
				.len = NFC_DEVICE_NAME_MAXSIZE },
	[NFC_ATTR_PROTOCOLS] = { .type = NLA_U32 },
	[NFC_ATTR_COMM_MODE] = { .type = NLA_U8 },
	[NFC_ATTR_RF_MODE] = { .type = NLA_U8 },
	[NFC_ATTR_DEVICE_POWERED] = { .type = NLA_U8 },
	[NFC_ATTR_IM_PROTOCOLS] = { .type = NLA_U32 },
	[NFC_ATTR_TM_PROTOCOLS] = { .type = NLA_U32 },
};

static int nfc_genl_send_target(struct sk_buff *msg, struct nfc_target *target,
				struct netlink_callback *cb, int flags)
{
	void *hdr;

	hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
			  &nfc_genl_family, flags, NFC_CMD_GET_TARGET);
	if (!hdr)
		return -EMSGSIZE;

	genl_dump_check_consistent(cb, hdr, &nfc_genl_family);

	if (nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target->idx) ||
	    nla_put_u32(msg, NFC_ATTR_PROTOCOLS, target->supported_protocols) ||
	    nla_put_u16(msg, NFC_ATTR_TARGET_SENS_RES, target->sens_res) ||
	    nla_put_u8(msg, NFC_ATTR_TARGET_SEL_RES, target->sel_res))
		goto nla_put_failure;
	if (target->nfcid1_len > 0 &&
	    nla_put(msg, NFC_ATTR_TARGET_NFCID1, target->nfcid1_len,
		    target->nfcid1))
		goto nla_put_failure;
	if (target->sensb_res_len > 0 &&
	    nla_put(msg, NFC_ATTR_TARGET_SENSB_RES, target->sensb_res_len,
		    target->sensb_res))
		goto nla_put_failure;
	if (target->sensf_res_len > 0 &&
	    nla_put(msg, NFC_ATTR_TARGET_SENSF_RES, target->sensf_res_len,
		    target->sensf_res))
		goto nla_put_failure;

	return genlmsg_end(msg, hdr);

nla_put_failure:
	genlmsg_cancel(msg, hdr);
	return -EMSGSIZE;
}

static struct nfc_dev *__get_device_from_cb(struct netlink_callback *cb)
{
	struct nfc_dev *dev;
	int rc;
	u32 idx;

	rc = nlmsg_parse(cb->nlh, GENL_HDRLEN + nfc_genl_family.hdrsize,
			 nfc_genl_family.attrbuf,
			 nfc_genl_family.maxattr,
			 nfc_genl_policy);
	if (rc < 0)
		return ERR_PTR(rc);

	if (!nfc_genl_family.attrbuf[NFC_ATTR_DEVICE_INDEX])
		return ERR_PTR(-EINVAL);

	idx = nla_get_u32(nfc_genl_family.attrbuf[NFC_ATTR_DEVICE_INDEX]);

	dev = nfc_get_device(idx);
	if (!dev)
		return ERR_PTR(-ENODEV);

	return dev;
}

static int nfc_genl_dump_targets(struct sk_buff *skb,
				 struct netlink_callback *cb)
{
	int i = cb->args[0];
	struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
	int rc;

	if (!dev) {
		dev = __get_device_from_cb(cb);
		if (IS_ERR(dev))
			return PTR_ERR(dev);

		cb->args[1] = (long) dev;
	}

	device_lock(&dev->dev);

	cb->seq = dev->targets_generation;

	while (i < dev->n_targets) {
		rc = nfc_genl_send_target(skb, &dev->targets[i], cb,
					  NLM_F_MULTI);
		if (rc < 0)
			break;

		i++;
	}

	device_unlock(&dev->dev);

	cb->args[0] = i;

	return skb->len;
}

static int nfc_genl_dump_targets_done(struct netlink_callback *cb)
{
	struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];

	if (dev)
		nfc_put_device(dev);

	return 0;
}

int nfc_genl_targets_found(struct nfc_dev *dev)
{
	struct sk_buff *msg;
	void *hdr;

	dev->genl_data.poll_req_pid = 0;

	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
	if (!msg)
		return -ENOMEM;

	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
			  NFC_EVENT_TARGETS_FOUND);
	if (!hdr)
		goto free_msg;

	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
		goto nla_put_failure;

	genlmsg_end(msg, hdr);

	return genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);

nla_put_failure:
	genlmsg_cancel(msg, hdr);
free_msg:
	nlmsg_free(msg);
	return -EMSGSIZE;
}

int nfc_genl_target_lost(struct nfc_dev *dev, u32 target_idx)
{
	struct sk_buff *msg;
	void *hdr;

	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!msg)
		return -ENOMEM;

	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
			  NFC_EVENT_TARGET_LOST);
	if (!hdr)
		goto free_msg;

	if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
	    nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
		goto nla_put_failure;

	genlmsg_end(msg, hdr);

	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);

	return 0;

nla_put_failure:
	genlmsg_cancel(msg, hdr);
free_msg:
	nlmsg_free(msg);
	return -EMSGSIZE;
}

int nfc_genl_tm_activated(struct nfc_dev *dev, u32 protocol)
{
	struct sk_buff *msg;
	void *hdr;

	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!msg)
		return -ENOMEM;

	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
			  NFC_EVENT_TM_ACTIVATED);
	if (!hdr)
		goto free_msg;

	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
		goto nla_put_failure;
	if (nla_put_u32(msg, NFC_ATTR_TM_PROTOCOLS, protocol))
		goto nla_put_failure;

	genlmsg_end(msg, hdr);

	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);

	return 0;

nla_put_failure:
	genlmsg_cancel(msg, hdr);
free_msg:
	nlmsg_free(msg);
	return -EMSGSIZE;
}

int nfc_genl_tm_deactivated(struct nfc_dev *dev)
{
	struct sk_buff *msg;
	void *hdr;

	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!msg)
		return -ENOMEM;

	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
			  NFC_EVENT_TM_DEACTIVATED);
	if (!hdr)
		goto free_msg;

	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
		goto nla_put_failure;

	genlmsg_end(msg, hdr);

	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);

	return 0;

nla_put_failure:
	genlmsg_cancel(msg, hdr);
free_msg:
	nlmsg_free(msg);
	return -EMSGSIZE;
}

int nfc_genl_device_added(struct nfc_dev *dev)
{
	struct sk_buff *msg;
	void *hdr;

	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!msg)
		return -ENOMEM;

	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
			  NFC_EVENT_DEVICE_ADDED);
	if (!hdr)
		goto free_msg;

	if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
	    nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
	    nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
	    nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up))
		goto nla_put_failure;

	genlmsg_end(msg, hdr);

	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);

	return 0;

nla_put_failure:
	genlmsg_cancel(msg, hdr);
free_msg:
	nlmsg_free(msg);
	return -EMSGSIZE;
}

int nfc_genl_device_removed(struct nfc_dev *dev)
{
	struct sk_buff *msg;
	void *hdr;

	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!msg)
		return -ENOMEM;

	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
			  NFC_EVENT_DEVICE_REMOVED);
	if (!hdr)
		goto free_msg;

	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
		goto nla_put_failure;

	genlmsg_end(msg, hdr);

	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);

	return 0;

nla_put_failure:
	genlmsg_cancel(msg, hdr);
free_msg:
	nlmsg_free(msg);
	return -EMSGSIZE;
}

static int nfc_genl_send_device(struct sk_buff *msg, struct nfc_dev *dev,
				u32 pid, u32 seq,
				struct netlink_callback *cb,
				int flags)
{
	void *hdr;

	hdr = genlmsg_put(msg, pid, seq, &nfc_genl_family, flags,
			  NFC_CMD_GET_DEVICE);
	if (!hdr)
		return -EMSGSIZE;

	if (cb)
		genl_dump_check_consistent(cb, hdr, &nfc_genl_family);

	if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
	    nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
	    nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
	    nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up))
		goto nla_put_failure;

	return genlmsg_end(msg, hdr);

nla_put_failure:
	genlmsg_cancel(msg, hdr);
	return -EMSGSIZE;
}

static int nfc_genl_dump_devices(struct sk_buff *skb,
				 struct netlink_callback *cb)
{
	struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
	struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
	bool first_call = false;

	if (!iter) {
		first_call = true;
		iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
		if (!iter)
			return -ENOMEM;
		cb->args[0] = (long) iter;
	}

	mutex_lock(&nfc_devlist_mutex);

	cb->seq = nfc_devlist_generation;

	if (first_call) {
		nfc_device_iter_init(iter);
		dev = nfc_device_iter_next(iter);
	}

	while (dev) {
		int rc;

		rc = nfc_genl_send_device(skb, dev, NETLINK_CB(cb->skb).pid,
					  cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
		if (rc < 0)
			break;

		dev = nfc_device_iter_next(iter);
	}

	mutex_unlock(&nfc_devlist_mutex);

	cb->args[1] = (long) dev;

	return skb->len;
}

static int nfc_genl_dump_devices_done(struct netlink_callback *cb)
{
	struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];

	nfc_device_iter_exit(iter);
	kfree(iter);

	return 0;
}

int nfc_genl_dep_link_up_event(struct nfc_dev *dev, u32 target_idx,
			       u8 comm_mode, u8 rf_mode)
{
	struct sk_buff *msg;
	void *hdr;

	pr_debug("DEP link is up\n");

	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
	if (!msg)
		return -ENOMEM;

	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, NFC_CMD_DEP_LINK_UP);
	if (!hdr)
		goto free_msg;

	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
		goto nla_put_failure;
	if (rf_mode == NFC_RF_INITIATOR &&
	    nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
		goto nla_put_failure;
	if (nla_put_u8(msg, NFC_ATTR_COMM_MODE, comm_mode) ||
	    nla_put_u8(msg, NFC_ATTR_RF_MODE, rf_mode))
		goto nla_put_failure;

	genlmsg_end(msg, hdr);

	dev->dep_link_up = true;

	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);

	return 0;

nla_put_failure:
	genlmsg_cancel(msg, hdr);
free_msg:
	nlmsg_free(msg);
	return -EMSGSIZE;
}

int nfc_genl_dep_link_down_event(struct nfc_dev *dev)
{
	struct sk_buff *msg;
	void *hdr;

	pr_debug("DEP link is down\n");

	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
	if (!msg)
		return -ENOMEM;

	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
			  NFC_CMD_DEP_LINK_DOWN);
	if (!hdr)
		goto free_msg;

	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
		goto nla_put_failure;

	genlmsg_end(msg, hdr);

	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);

	return 0;

nla_put_failure:
	genlmsg_cancel(msg, hdr);
free_msg:
	nlmsg_free(msg);
	return -EMSGSIZE;
}

static int nfc_genl_get_device(struct sk_buff *skb, struct genl_info *info)
{
	struct sk_buff *msg;
	struct nfc_dev *dev;
	u32 idx;
	int rc = -ENOBUFS;

	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
		return -EINVAL;

	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);

	dev = nfc_get_device(idx);
	if (!dev)
		return -ENODEV;

	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!msg) {
		rc = -ENOMEM;
		goto out_putdev;
	}

	rc = nfc_genl_send_device(msg, dev, info->snd_pid, info->snd_seq,
				  NULL, 0);
	if (rc < 0)
		goto out_free;

	nfc_put_device(dev);

	return genlmsg_reply(msg, info);

out_free:
	nlmsg_free(msg);
out_putdev:
	nfc_put_device(dev);
	return rc;
}

static int nfc_genl_dev_up(struct sk_buff *skb, struct genl_info *info)
{
	struct nfc_dev *dev;
	int rc;
	u32 idx;

	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
		return -EINVAL;

	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);

	dev = nfc_get_device(idx);
	if (!dev)
		return -ENODEV;

	rc = nfc_dev_up(dev);

	nfc_put_device(dev);
	return rc;
}

static int nfc_genl_dev_down(struct sk_buff *skb, struct genl_info *info)
{
	struct nfc_dev *dev;
	int rc;
	u32 idx;

	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
		return -EINVAL;

	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);

	dev = nfc_get_device(idx);
	if (!dev)
		return -ENODEV;

	rc = nfc_dev_down(dev);

	nfc_put_device(dev);
	return rc;
}

static int nfc_genl_start_poll(struct sk_buff *skb, struct genl_info *info)
{
	struct nfc_dev *dev;
	int rc;
	u32 idx;
	u32 im_protocols = 0, tm_protocols = 0;

	pr_debug("Poll start\n");

	if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
	    ((!info->attrs[NFC_ATTR_IM_PROTOCOLS] &&
	      !info->attrs[NFC_ATTR_PROTOCOLS]) &&
	     !info->attrs[NFC_ATTR_TM_PROTOCOLS]))
		return -EINVAL;

	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);

	if (info->attrs[NFC_ATTR_TM_PROTOCOLS])
		tm_protocols = nla_get_u32(info->attrs[NFC_ATTR_TM_PROTOCOLS]);

	if (info->attrs[NFC_ATTR_IM_PROTOCOLS])
		im_protocols = nla_get_u32(info->attrs[NFC_ATTR_IM_PROTOCOLS]);
	else if (info->attrs[NFC_ATTR_PROTOCOLS])
		im_protocols = nla_get_u32(info->attrs[NFC_ATTR_PROTOCOLS]);

	dev = nfc_get_device(idx);
	if (!dev)
		return -ENODEV;

	mutex_lock(&dev->genl_data.genl_data_mutex);

	rc = nfc_start_poll(dev, im_protocols, tm_protocols);
	if (!rc)
		dev->genl_data.poll_req_pid = info->snd_pid;

	mutex_unlock(&dev->genl_data.genl_data_mutex);

	nfc_put_device(dev);
	return rc;
}

static int nfc_genl_stop_poll(struct sk_buff *skb, struct genl_info *info)
{
	struct nfc_dev *dev;
	int rc;
	u32 idx;

	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
		return -EINVAL;

	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);

	dev = nfc_get_device(idx);
	if (!dev)
		return -ENODEV;

	mutex_lock(&dev->genl_data.genl_data_mutex);

	if (dev->genl_data.poll_req_pid != info->snd_pid) {
		rc = -EBUSY;
		goto out;
	}

	rc = nfc_stop_poll(dev);
	dev->genl_data.poll_req_pid = 0;

out:
	mutex_unlock(&dev->genl_data.genl_data_mutex);
	nfc_put_device(dev);
	return rc;
}

static int nfc_genl_dep_link_up(struct sk_buff *skb, struct genl_info *info)
{
	struct nfc_dev *dev;
	int rc, tgt_idx;
	u32 idx;
	u8 comm;

	pr_debug("DEP link up\n");

	if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
	    !info->attrs[NFC_ATTR_COMM_MODE])
		return -EINVAL;

	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
	if (!info->attrs[NFC_ATTR_TARGET_INDEX])
		tgt_idx = NFC_TARGET_IDX_ANY;
	else
		tgt_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]);

	comm = nla_get_u8(info->attrs[NFC_ATTR_COMM_MODE]);

	if (comm != NFC_COMM_ACTIVE && comm != NFC_COMM_PASSIVE)
		return -EINVAL;

	dev = nfc_get_device(idx);
	if (!dev)
		return -ENODEV;

	rc = nfc_dep_link_up(dev, tgt_idx, comm);

	nfc_put_device(dev);

	return rc;
}

static int nfc_genl_dep_link_down(struct sk_buff *skb, struct genl_info *info)
{
	struct nfc_dev *dev;
	int rc;
	u32 idx;

	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
		return -EINVAL;

	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);

	dev = nfc_get_device(idx);
	if (!dev)
		return -ENODEV;

	rc = nfc_dep_link_down(dev);

	nfc_put_device(dev);
	return rc;
}

static struct genl_ops nfc_genl_ops[] = {
	{
		.cmd = NFC_CMD_GET_DEVICE,
		.doit = nfc_genl_get_device,
		.dumpit = nfc_genl_dump_devices,
		.done = nfc_genl_dump_devices_done,
		.policy = nfc_genl_policy,
	},
	{
		.cmd = NFC_CMD_DEV_UP,
		.doit = nfc_genl_dev_up,
		.policy = nfc_genl_policy,
	},
	{
		.cmd = NFC_CMD_DEV_DOWN,
		.doit = nfc_genl_dev_down,
		.policy = nfc_genl_policy,
	},
	{
		.cmd = NFC_CMD_START_POLL,
		.doit = nfc_genl_start_poll,
		.policy = nfc_genl_policy,
	},
	{
		.cmd = NFC_CMD_STOP_POLL,
		.doit = nfc_genl_stop_poll,
		.policy = nfc_genl_policy,
	},
	{
		.cmd = NFC_CMD_DEP_LINK_UP,
		.doit = nfc_genl_dep_link_up,
		.policy = nfc_genl_policy,
	},
	{
		.cmd = NFC_CMD_DEP_LINK_DOWN,
		.doit = nfc_genl_dep_link_down,
		.policy = nfc_genl_policy,
	},
	{
		.cmd = NFC_CMD_GET_TARGET,
		.dumpit = nfc_genl_dump_targets,
		.done = nfc_genl_dump_targets_done,
		.policy = nfc_genl_policy,
	},
};

static int nfc_genl_rcv_nl_event(struct notifier_block *this,
				 unsigned long event, void *ptr)
{
	struct netlink_notify *n = ptr;
	struct class_dev_iter iter;
	struct nfc_dev *dev;

	if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC)
		goto out;

	pr_debug("NETLINK_URELEASE event from id %d\n", n->pid);

	nfc_device_iter_init(&iter);
	dev = nfc_device_iter_next(&iter);

	while (dev) {
		if (dev->genl_data.poll_req_pid == n->pid) {
			nfc_stop_poll(dev);
			dev->genl_data.poll_req_pid = 0;
		}
		dev = nfc_device_iter_next(&iter);
	}

	nfc_device_iter_exit(&iter);

out:
	return NOTIFY_DONE;
}

void nfc_genl_data_init(struct nfc_genl_data *genl_data)
{
	genl_data->poll_req_pid = 0;
	mutex_init(&genl_data->genl_data_mutex);
}

void nfc_genl_data_exit(struct nfc_genl_data *genl_data)
{
	mutex_destroy(&genl_data->genl_data_mutex);
}

static struct notifier_block nl_notifier = {
	.notifier_call  = nfc_genl_rcv_nl_event,
};

/**
 * nfc_genl_init() - Initialize netlink interface
 *
 * This initialization function registers the nfc netlink family.
 */
int __init nfc_genl_init(void)
{
	int rc;

	rc = genl_register_family_with_ops(&nfc_genl_family, nfc_genl_ops,
					   ARRAY_SIZE(nfc_genl_ops));
	if (rc)
		return rc;

	rc = genl_register_mc_group(&nfc_genl_family, &nfc_genl_event_mcgrp);

	netlink_register_notifier(&nl_notifier);

	return rc;
}

/**
 * nfc_genl_exit() - Deinitialize netlink interface
 *
 * This exit function unregisters the nfc netlink family.
 */
void nfc_genl_exit(void)
{
	netlink_unregister_notifier(&nl_notifier);
	genl_unregister_family(&nfc_genl_family);
}
Commit	Line	Data
4d12b8b1 LRV	1	/*
	2	* Copyright (C) 2011 Instituto Nokia de Tecnologia
	3	*
	4	* Authors:
	5	* Lauro Ramos Venancio <lauro.venancio@openbossa.org>
	6	* Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
	7	*
	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.
	12	*
	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.
	17	*
	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.
	22	*/
	23
52858b51	24	#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
20c239c1	25
4d12b8b1 LRV	26	#include <net/genetlink.h>
	27	#include <linux/nfc.h>
	28	#include <linux/slab.h>
	29
	30	#include "nfc.h"
	31
	32	static struct genl_multicast_group nfc_genl_event_mcgrp = {
	33	.name = NFC_GENL_MCAST_EVENT_NAME,
	34	};
	35
e5fe4cf8	36	static struct genl_family nfc_genl_family = {
4d12b8b1 LRV	37	.id = GENL_ID_GENERATE,
	38	.hdrsize = 0,
	39	.name = NFC_GENL_NAME,
	40	.version = NFC_GENL_VERSION,
	41	.maxattr = NFC_ATTR_MAX,
	42	};
	43
	44	static const struct nla_policy nfc_genl_policy[NFC_ATTR_MAX + 1] = {
	45	[NFC_ATTR_DEVICE_INDEX] = { .type = NLA_U32 },
	46	[NFC_ATTR_DEVICE_NAME] = { .type = NLA_STRING,
	47	.len = NFC_DEVICE_NAME_MAXSIZE },
	48	[NFC_ATTR_PROTOCOLS] = { .type = NLA_U32 },
1ed28f61 SO	49	[NFC_ATTR_COMM_MODE] = { .type = NLA_U8 },
1ed28f61 SO	50	[NFC_ATTR_RF_MODE] = { .type = NLA_U8 },
c970a1ac	51	[NFC_ATTR_DEVICE_POWERED] = { .type = NLA_U8 },
fe7c5800 SO	52	[NFC_ATTR_IM_PROTOCOLS] = { .type = NLA_U32 },
fe7c5800 SO	53	[NFC_ATTR_TM_PROTOCOLS] = { .type = NLA_U32 },
4d12b8b1 LRV	54	};
	55
	56	static int nfc_genl_send_target(struct sk_buff msg, struct nfc_target target,
0a40acb2	57	struct netlink_callback *cb, int flags)
4d12b8b1 LRV	58	{
	59	void *hdr;
	60
4d12b8b1	61	hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
0a40acb2	62	&nfc_genl_family, flags, NFC_CMD_GET_TARGET);
4d12b8b1 LRV	63	if (!hdr)
	64	return -EMSGSIZE;
	65
	66	genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
	67
1e6428d8 DM	68	if (nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target->idx) \|\|
	69	nla_put_u32(msg, NFC_ATTR_PROTOCOLS, target->supported_protocols) \|\|
	70	nla_put_u16(msg, NFC_ATTR_TARGET_SENS_RES, target->sens_res) \|\|
	71	nla_put_u8(msg, NFC_ATTR_TARGET_SEL_RES, target->sel_res))
	72	goto nla_put_failure;
	73	if (target->nfcid1_len > 0 &&
	74	nla_put(msg, NFC_ATTR_TARGET_NFCID1, target->nfcid1_len,
	75	target->nfcid1))
	76	goto nla_put_failure;
	77	if (target->sensb_res_len > 0 &&
	78	nla_put(msg, NFC_ATTR_TARGET_SENSB_RES, target->sensb_res_len,
	79	target->sensb_res))
	80	goto nla_put_failure;
	81	if (target->sensf_res_len > 0 &&
	82	nla_put(msg, NFC_ATTR_TARGET_SENSF_RES, target->sensf_res_len,
	83	target->sensf_res))
	84	goto nla_put_failure;
4d12b8b1 LRV	85
	86	return genlmsg_end(msg, hdr);
	87
	88	nla_put_failure:
	89	genlmsg_cancel(msg, hdr);
	90	return -EMSGSIZE;
	91	}
	92
	93	static struct nfc_dev __get_device_from_cb(struct netlink_callback cb)
	94	{
	95	struct nfc_dev *dev;
	96	int rc;
	97	u32 idx;
	98
	99	rc = nlmsg_parse(cb->nlh, GENL_HDRLEN + nfc_genl_family.hdrsize,
0a40acb2 SO	100	nfc_genl_family.attrbuf,
	101	nfc_genl_family.maxattr,
	102	nfc_genl_policy);
4d12b8b1 LRV	103	if (rc < 0)
	104	return ERR_PTR(rc);
	105
	106	if (!nfc_genl_family.attrbuf[NFC_ATTR_DEVICE_INDEX])
	107	return ERR_PTR(-EINVAL);
	108
	109	idx = nla_get_u32(nfc_genl_family.attrbuf[NFC_ATTR_DEVICE_INDEX]);
	110
	111	dev = nfc_get_device(idx);
	112	if (!dev)
	113	return ERR_PTR(-ENODEV);
	114
	115	return dev;
	116	}
	117
	118	static int nfc_genl_dump_targets(struct sk_buff *skb,
0a40acb2	119	struct netlink_callback *cb)
4d12b8b1 LRV	120	{
	121	int i = cb->args[0];
	122	struct nfc_dev dev = (struct nfc_dev ) cb->args[1];
	123	int rc;
	124
4d12b8b1 LRV	125	if (!dev) {
	126	dev = __get_device_from_cb(cb);
	127	if (IS_ERR(dev))
	128	return PTR_ERR(dev);
	129
	130	cb->args[1] = (long) dev;
	131	}
	132
d4ccb132	133	device_lock(&dev->dev);
4d12b8b1 LRV	134
	135	cb->seq = dev->targets_generation;
	136
	137	while (i < dev->n_targets) {
	138	rc = nfc_genl_send_target(skb, &dev->targets[i], cb,
0a40acb2	139	NLM_F_MULTI);
4d12b8b1 LRV	140	if (rc < 0)
	141	break;
	142
	143	i++;
	144	}
	145
d4ccb132	146	device_unlock(&dev->dev);
4d12b8b1 LRV	147
	148	cb->args[0] = i;
	149
	150	return skb->len;
	151	}
	152
	153	static int nfc_genl_dump_targets_done(struct netlink_callback *cb)
	154	{
	155	struct nfc_dev dev = (struct nfc_dev ) cb->args[1];
	156
4d12b8b1 LRV	157	if (dev)
	158	nfc_put_device(dev);
	159
	160	return 0;
	161	}
	162
	163	int nfc_genl_targets_found(struct nfc_dev *dev)
	164	{
	165	struct sk_buff *msg;
	166	void *hdr;
	167
4d12b8b1 LRV	168	dev->genl_data.poll_req_pid = 0;
	169
	170	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
	171	if (!msg)
	172	return -ENOMEM;
	173
	174	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
0a40acb2	175	NFC_EVENT_TARGETS_FOUND);
4d12b8b1 LRV	176	if (!hdr)
	177	goto free_msg;
	178
1e6428d8 DM	179	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
1e6428d8 DM	180	goto nla_put_failure;
4d12b8b1 LRV	181
	182	genlmsg_end(msg, hdr);
	183
	184	return genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
	185
	186	nla_put_failure:
	187	genlmsg_cancel(msg, hdr);
	188	free_msg:
	189	nlmsg_free(msg);
	190	return -EMSGSIZE;
	191	}
	192
8112a5c9 SO	193	int nfc_genl_target_lost(struct nfc_dev *dev, u32 target_idx)
	194	{
	195	struct sk_buff *msg;
	196	void *hdr;
	197
	198	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	199	if (!msg)
	200	return -ENOMEM;
	201
	202	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
	203	NFC_EVENT_TARGET_LOST);
	204	if (!hdr)
	205	goto free_msg;
	206
59ef43e6 JL	207	if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) \|\|
	208	nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
	209	goto nla_put_failure;
8112a5c9 SO	210
	211	genlmsg_end(msg, hdr);
	212
	213	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
	214
	215	return 0;
	216
fc40a8c1 SO	217	nla_put_failure:
	218	genlmsg_cancel(msg, hdr);
	219	free_msg:
	220	nlmsg_free(msg);
	221	return -EMSGSIZE;
	222	}
	223
	224	int nfc_genl_tm_activated(struct nfc_dev *dev, u32 protocol)
	225	{
	226	struct sk_buff *msg;
	227	void *hdr;
	228
	229	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	230	if (!msg)
	231	return -ENOMEM;
	232
	233	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
	234	NFC_EVENT_TM_ACTIVATED);
	235	if (!hdr)
	236	goto free_msg;
	237
	238	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
	239	goto nla_put_failure;
	240	if (nla_put_u32(msg, NFC_ATTR_TM_PROTOCOLS, protocol))
	241	goto nla_put_failure;
	242
	243	genlmsg_end(msg, hdr);
	244
	245	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
	246
	247	return 0;
	248
	249	nla_put_failure:
	250	genlmsg_cancel(msg, hdr);
	251	free_msg:
	252	nlmsg_free(msg);
	253	return -EMSGSIZE;
	254	}
	255
	256	int nfc_genl_tm_deactivated(struct nfc_dev *dev)
	257	{
	258	struct sk_buff *msg;
	259	void *hdr;
	260
	261	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	262	if (!msg)
	263	return -ENOMEM;
	264
	265	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
	266	NFC_EVENT_TM_DEACTIVATED);
	267	if (!hdr)
	268	goto free_msg;
	269
	270	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
	271	goto nla_put_failure;
	272
	273	genlmsg_end(msg, hdr);
	274
	275	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
	276
	277	return 0;
	278
8112a5c9 SO	279	nla_put_failure:
	280	genlmsg_cancel(msg, hdr);
	281	free_msg:
	282	nlmsg_free(msg);
	283	return -EMSGSIZE;
	284	}
	285
4d12b8b1 LRV	286	int nfc_genl_device_added(struct nfc_dev *dev)
	287	{
	288	struct sk_buff *msg;
	289	void *hdr;
	290
4d12b8b1 LRV	291	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	292	if (!msg)
	293	return -ENOMEM;
	294
	295	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
0a40acb2	296	NFC_EVENT_DEVICE_ADDED);
4d12b8b1 LRV	297	if (!hdr)
	298	goto free_msg;
	299
1e6428d8 DM	300	if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) \|\|
	301	nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) \|\|
	302	nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) \|\|
	303	nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up))
	304	goto nla_put_failure;
4d12b8b1 LRV	305
	306	genlmsg_end(msg, hdr);
	307
	308	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
	309
	310	return 0;
	311
	312	nla_put_failure:
	313	genlmsg_cancel(msg, hdr);
	314	free_msg:
	315	nlmsg_free(msg);
	316	return -EMSGSIZE;
	317	}
	318
	319	int nfc_genl_device_removed(struct nfc_dev *dev)
	320	{
	321	struct sk_buff *msg;
	322	void *hdr;
	323
4d12b8b1 LRV	324	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	325	if (!msg)
	326	return -ENOMEM;
	327
	328	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
0a40acb2	329	NFC_EVENT_DEVICE_REMOVED);
4d12b8b1 LRV	330	if (!hdr)
	331	goto free_msg;
	332
1e6428d8 DM	333	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
1e6428d8 DM	334	goto nla_put_failure;
4d12b8b1 LRV	335
	336	genlmsg_end(msg, hdr);
	337
	338	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
	339
	340	return 0;
	341
	342	nla_put_failure:
	343	genlmsg_cancel(msg, hdr);
	344	free_msg:
	345	nlmsg_free(msg);
	346	return -EMSGSIZE;
	347	}
	348
	349	static int nfc_genl_send_device(struct sk_buff msg, struct nfc_dev dev,
0a40acb2 SO	350	u32 pid, u32 seq,
	351	struct netlink_callback *cb,
	352	int flags)
4d12b8b1 LRV	353	{
	354	void *hdr;
	355
4d12b8b1	356	hdr = genlmsg_put(msg, pid, seq, &nfc_genl_family, flags,
0a40acb2	357	NFC_CMD_GET_DEVICE);
4d12b8b1 LRV	358	if (!hdr)
	359	return -EMSGSIZE;
	360
	361	if (cb)
	362	genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
	363
1e6428d8 DM	364	if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) \|\|
	365	nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) \|\|
	366	nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) \|\|
	367	nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up))
	368	goto nla_put_failure;
4d12b8b1 LRV	369
	370	return genlmsg_end(msg, hdr);
	371
	372	nla_put_failure:
	373	genlmsg_cancel(msg, hdr);
	374	return -EMSGSIZE;
	375	}
	376
	377	static int nfc_genl_dump_devices(struct sk_buff *skb,
0a40acb2	378	struct netlink_callback *cb)
4d12b8b1 LRV	379	{
	380	struct class_dev_iter iter = (struct class_dev_iter ) cb->args[0];
	381	struct nfc_dev dev = (struct nfc_dev ) cb->args[1];
	382	bool first_call = false;
	383
4d12b8b1 LRV	384	if (!iter) {
	385	first_call = true;
	386	iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
	387	if (!iter)
	388	return -ENOMEM;
	389	cb->args[0] = (long) iter;
	390	}
	391
	392	mutex_lock(&nfc_devlist_mutex);
	393
	394	cb->seq = nfc_devlist_generation;
	395
	396	if (first_call) {
	397	nfc_device_iter_init(iter);
	398	dev = nfc_device_iter_next(iter);
	399	}
	400
	401	while (dev) {
	402	int rc;
	403
	404	rc = nfc_genl_send_device(skb, dev, NETLINK_CB(cb->skb).pid,
0a40acb2	405	cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
4d12b8b1 LRV	406	if (rc < 0)
	407	break;
	408
	409	dev = nfc_device_iter_next(iter);
	410	}
	411
	412	mutex_unlock(&nfc_devlist_mutex);
	413
	414	cb->args[1] = (long) dev;
	415
	416	return skb->len;
	417	}
	418
	419	static int nfc_genl_dump_devices_done(struct netlink_callback *cb)
	420	{
	421	struct class_dev_iter iter = (struct class_dev_iter ) cb->args[0];
	422
4d12b8b1 LRV	423	nfc_device_iter_exit(iter);
	424	kfree(iter);
	425
	426	return 0;
	427	}
	428
1ed28f61	429	int nfc_genl_dep_link_up_event(struct nfc_dev *dev, u32 target_idx,
0a40acb2	430	u8 comm_mode, u8 rf_mode)
1ed28f61 SO	431	{
	432	struct sk_buff *msg;
	433	void *hdr;
	434
	435	pr_debug("DEP link is up\n");
	436
	437	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
	438	if (!msg)
	439	return -ENOMEM;
	440
0a40acb2	441	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, NFC_CMD_DEP_LINK_UP);
1ed28f61 SO	442	if (!hdr)
	443	goto free_msg;
	444
1e6428d8 DM	445	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
	446	goto nla_put_failure;
	447	if (rf_mode == NFC_RF_INITIATOR &&
	448	nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
	449	goto nla_put_failure;
	450	if (nla_put_u8(msg, NFC_ATTR_COMM_MODE, comm_mode) \|\|
	451	nla_put_u8(msg, NFC_ATTR_RF_MODE, rf_mode))
	452	goto nla_put_failure;
1ed28f61 SO	453
	454	genlmsg_end(msg, hdr);
	455
	456	dev->dep_link_up = true;
	457
	458	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
	459
	460	return 0;
	461
	462	nla_put_failure:
	463	genlmsg_cancel(msg, hdr);
	464	free_msg:
	465	nlmsg_free(msg);
	466	return -EMSGSIZE;
	467	}
	468
	469	int nfc_genl_dep_link_down_event(struct nfc_dev *dev)
	470	{
	471	struct sk_buff *msg;
	472	void *hdr;
	473
	474	pr_debug("DEP link is down\n");
	475
	476	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
	477	if (!msg)
	478	return -ENOMEM;
	479
	480	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
0a40acb2	481	NFC_CMD_DEP_LINK_DOWN);
1ed28f61 SO	482	if (!hdr)
	483	goto free_msg;
	484
1e6428d8 DM	485	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
1e6428d8 DM	486	goto nla_put_failure;
1ed28f61 SO	487
	488	genlmsg_end(msg, hdr);
	489
	490	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
	491
	492	return 0;
	493
	494	nla_put_failure:
	495	genlmsg_cancel(msg, hdr);
	496	free_msg:
	497	nlmsg_free(msg);
	498	return -EMSGSIZE;
	499	}
	500
4d12b8b1 LRV	501	static int nfc_genl_get_device(struct sk_buff skb, struct genl_info info)
	502	{
	503	struct sk_buff *msg;
	504	struct nfc_dev *dev;
	505	u32 idx;
	506	int rc = -ENOBUFS;
	507
4d12b8b1 LRV	508	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
	509	return -EINVAL;
	510
	511	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
	512
	513	dev = nfc_get_device(idx);
	514	if (!dev)
	515	return -ENODEV;
	516
	517	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	518	if (!msg) {
	519	rc = -ENOMEM;
	520	goto out_putdev;
	521	}
	522
	523	rc = nfc_genl_send_device(msg, dev, info->snd_pid, info->snd_seq,
0a40acb2	524	NULL, 0);
4d12b8b1 LRV	525	if (rc < 0)
	526	goto out_free;
	527
	528	nfc_put_device(dev);
	529
	530	return genlmsg_reply(msg, info);
	531
	532	out_free:
	533	nlmsg_free(msg);
	534	out_putdev:
	535	nfc_put_device(dev);
	536	return rc;
	537	}
	538
8b3fe7b5 IE	539	static int nfc_genl_dev_up(struct sk_buff skb, struct genl_info info)
	540	{
	541	struct nfc_dev *dev;
	542	int rc;
	543	u32 idx;
	544
8b3fe7b5 IE	545	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
	546	return -EINVAL;
	547
	548	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
	549
	550	dev = nfc_get_device(idx);
	551	if (!dev)
	552	return -ENODEV;
	553
	554	rc = nfc_dev_up(dev);
	555
	556	nfc_put_device(dev);
	557	return rc;
	558	}
	559
	560	static int nfc_genl_dev_down(struct sk_buff skb, struct genl_info info)
	561	{
	562	struct nfc_dev *dev;
	563	int rc;
	564	u32 idx;
	565
8b3fe7b5 IE	566	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
	567	return -EINVAL;
	568
	569	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
	570
	571	dev = nfc_get_device(idx);
	572	if (!dev)
	573	return -ENODEV;
	574
	575	rc = nfc_dev_down(dev);
	576
	577	nfc_put_device(dev);
	578	return rc;
	579	}
	580
4d12b8b1 LRV	581	static int nfc_genl_start_poll(struct sk_buff skb, struct genl_info info)
	582	{
	583	struct nfc_dev *dev;
	584	int rc;
	585	u32 idx;
fe7c5800	586	u32 im_protocols = 0, tm_protocols = 0;
4d12b8b1	587
1ed28f61 SO	588	pr_debug("Poll start\n");
1ed28f61 SO	589
4d12b8b1	590	if (!info->attrs[NFC_ATTR_DEVICE_INDEX] \|\|
fe7c5800 SO	591	((!info->attrs[NFC_ATTR_IM_PROTOCOLS] &&
	592	!info->attrs[NFC_ATTR_PROTOCOLS]) &&
	593	!info->attrs[NFC_ATTR_TM_PROTOCOLS]))
4d12b8b1 LRV	594	return -EINVAL;
	595
	596	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
fe7c5800 SO	597
	598	if (info->attrs[NFC_ATTR_TM_PROTOCOLS])
	599	tm_protocols = nla_get_u32(info->attrs[NFC_ATTR_TM_PROTOCOLS]);
fe7c5800 SO	600
	601	if (info->attrs[NFC_ATTR_IM_PROTOCOLS])
	602	im_protocols = nla_get_u32(info->attrs[NFC_ATTR_IM_PROTOCOLS]);
5e50ee3a SO	603	else if (info->attrs[NFC_ATTR_PROTOCOLS])
5e50ee3a SO	604	im_protocols = nla_get_u32(info->attrs[NFC_ATTR_PROTOCOLS]);
4d12b8b1 LRV	605
	606	dev = nfc_get_device(idx);
	607	if (!dev)
	608	return -ENODEV;
	609
	610	mutex_lock(&dev->genl_data.genl_data_mutex);
	611
fe7c5800	612	rc = nfc_start_poll(dev, im_protocols, tm_protocols);
4d12b8b1 LRV	613	if (!rc)
	614	dev->genl_data.poll_req_pid = info->snd_pid;
	615
	616	mutex_unlock(&dev->genl_data.genl_data_mutex);
	617
	618	nfc_put_device(dev);
	619	return rc;
	620	}
	621
	622	static int nfc_genl_stop_poll(struct sk_buff skb, struct genl_info info)
	623	{
	624	struct nfc_dev *dev;
	625	int rc;
	626	u32 idx;
	627
4d12b8b1 LRV	628	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
	629	return -EINVAL;
	630
	631	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
	632
	633	dev = nfc_get_device(idx);
	634	if (!dev)
	635	return -ENODEV;
	636
	637	mutex_lock(&dev->genl_data.genl_data_mutex);
	638
	639	if (dev->genl_data.poll_req_pid != info->snd_pid) {
	640	rc = -EBUSY;
	641	goto out;
	642	}
	643
	644	rc = nfc_stop_poll(dev);
	645	dev->genl_data.poll_req_pid = 0;
	646
	647	out:
	648	mutex_unlock(&dev->genl_data.genl_data_mutex);
	649	nfc_put_device(dev);
	650	return rc;
	651	}
	652
1ed28f61 SO	653	static int nfc_genl_dep_link_up(struct sk_buff skb, struct genl_info info)
	654	{
	655	struct nfc_dev *dev;
	656	int rc, tgt_idx;
	657	u32 idx;
47807d3d	658	u8 comm;
1ed28f61 SO	659
	660	pr_debug("DEP link up\n");
	661
	662	if (!info->attrs[NFC_ATTR_DEVICE_INDEX] \|\|
47807d3d	663	!info->attrs[NFC_ATTR_COMM_MODE])
1ed28f61 SO	664	return -EINVAL;
	665
	666	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
	667	if (!info->attrs[NFC_ATTR_TARGET_INDEX])
	668	tgt_idx = NFC_TARGET_IDX_ANY;
	669	else
	670	tgt_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]);
	671
	672	comm = nla_get_u8(info->attrs[NFC_ATTR_COMM_MODE]);
1ed28f61 SO	673
	674	if (comm != NFC_COMM_ACTIVE && comm != NFC_COMM_PASSIVE)
	675	return -EINVAL;
	676
1ed28f61 SO	677	dev = nfc_get_device(idx);
	678	if (!dev)
	679	return -ENODEV;
	680
47807d3d	681	rc = nfc_dep_link_up(dev, tgt_idx, comm);
1ed28f61 SO	682
	683	nfc_put_device(dev);
	684
	685	return rc;
	686	}
	687
	688	static int nfc_genl_dep_link_down(struct sk_buff skb, struct genl_info info)
	689	{
	690	struct nfc_dev *dev;
	691	int rc;
	692	u32 idx;
	693
	694	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
	695	return -EINVAL;
	696
	697	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
	698
	699	dev = nfc_get_device(idx);
	700	if (!dev)
	701	return -ENODEV;
	702
	703	rc = nfc_dep_link_down(dev);
	704
	705	nfc_put_device(dev);
	706	return rc;
	707	}
	708
4d12b8b1 LRV	709	static struct genl_ops nfc_genl_ops[] = {
	710	{
	711	.cmd = NFC_CMD_GET_DEVICE,
	712	.doit = nfc_genl_get_device,
	713	.dumpit = nfc_genl_dump_devices,
	714	.done = nfc_genl_dump_devices_done,
	715	.policy = nfc_genl_policy,
8b3fe7b5 IE	716	},
	717	{
	718	.cmd = NFC_CMD_DEV_UP,
	719	.doit = nfc_genl_dev_up,
	720	.policy = nfc_genl_policy,
	721	},
	722	{
	723	.cmd = NFC_CMD_DEV_DOWN,
	724	.doit = nfc_genl_dev_down,
	725	.policy = nfc_genl_policy,
4d12b8b1 LRV	726	},
	727	{
	728	.cmd = NFC_CMD_START_POLL,
	729	.doit = nfc_genl_start_poll,
	730	.policy = nfc_genl_policy,
	731	},
	732	{
	733	.cmd = NFC_CMD_STOP_POLL,
	734	.doit = nfc_genl_stop_poll,
	735	.policy = nfc_genl_policy,
	736	},
1ed28f61 SO	737	{
	738	.cmd = NFC_CMD_DEP_LINK_UP,
	739	.doit = nfc_genl_dep_link_up,
	740	.policy = nfc_genl_policy,
	741	},
	742	{
	743	.cmd = NFC_CMD_DEP_LINK_DOWN,
	744	.doit = nfc_genl_dep_link_down,
	745	.policy = nfc_genl_policy,
	746	},
4d12b8b1 LRV	747	{
	748	.cmd = NFC_CMD_GET_TARGET,
	749	.dumpit = nfc_genl_dump_targets,
	750	.done = nfc_genl_dump_targets_done,
	751	.policy = nfc_genl_policy,
	752	},
	753	};
	754
	755	static int nfc_genl_rcv_nl_event(struct notifier_block *this,
0a40acb2	756	unsigned long event, void *ptr)
4d12b8b1 LRV	757	{
	758	struct netlink_notify *n = ptr;
	759	struct class_dev_iter iter;
	760	struct nfc_dev *dev;
	761
	762	if (event != NETLINK_URELEASE \|\| n->protocol != NETLINK_GENERIC)
	763	goto out;
	764
20c239c1	765	pr_debug("NETLINK_URELEASE event from id %d\n", n->pid);
4d12b8b1 LRV	766
	767	nfc_device_iter_init(&iter);
	768	dev = nfc_device_iter_next(&iter);
	769
	770	while (dev) {
4d12b8b1 LRV	771	if (dev->genl_data.poll_req_pid == n->pid) {
	772	nfc_stop_poll(dev);
	773	dev->genl_data.poll_req_pid = 0;
	774	}
4d12b8b1 LRV	775	dev = nfc_device_iter_next(&iter);
	776	}
	777
	778	nfc_device_iter_exit(&iter);
	779
	780	out:
	781	return NOTIFY_DONE;
	782	}
	783
	784	void nfc_genl_data_init(struct nfc_genl_data *genl_data)
	785	{
	786	genl_data->poll_req_pid = 0;
	787	mutex_init(&genl_data->genl_data_mutex);
	788	}
	789
	790	void nfc_genl_data_exit(struct nfc_genl_data *genl_data)
	791	{
	792	mutex_destroy(&genl_data->genl_data_mutex);
	793	}
	794
	795	static struct notifier_block nl_notifier = {
	796	.notifier_call = nfc_genl_rcv_nl_event,
	797	};
	798
	799	/**
	800	* nfc_genl_init() - Initialize netlink interface
	801	*
	802	* This initialization function registers the nfc netlink family.
	803	*/
	804	int __init nfc_genl_init(void)
	805	{
	806	int rc;
	807
	808	rc = genl_register_family_with_ops(&nfc_genl_family, nfc_genl_ops,
0a40acb2	809	ARRAY_SIZE(nfc_genl_ops));
4d12b8b1 LRV	810	if (rc)
	811	return rc;
	812
	813	rc = genl_register_mc_group(&nfc_genl_family, &nfc_genl_event_mcgrp);
	814
	815	netlink_register_notifier(&nl_notifier);
	816
	817	return rc;
	818	}
	819
	820	/**
	821	* nfc_genl_exit() - Deinitialize netlink interface
	822	*
	823	* This exit function unregisters the nfc netlink family.
	824	*/
	825	void nfc_genl_exit(void)
	826	{
	827	netlink_unregister_notifier(&nl_notifier);
	828	genl_unregister_family(&nfc_genl_family);
	829	}