[linux-2.6-block.git] / drivers / nfc / nfcsim.c

/*
 * NFC hardware simulation driver
 * Copyright (c) 2013, Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope 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.
 *
 */

#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/nfc.h>
#include <net/nfc/nfc.h>

#define DEV_ERR(_dev, fmt, args...) nfc_err(&_dev->nfc_dev->dev, \
						"%s: " fmt, __func__, ## args)

#define DEV_DBG(_dev, fmt, args...) dev_dbg(&_dev->nfc_dev->dev, \
						"%s: " fmt, __func__, ## args)

#define NFCSIM_VERSION "0.1"

#define NFCSIM_POLL_NONE	0
#define NFCSIM_POLL_INITIATOR	1
#define NFCSIM_POLL_TARGET	2
#define NFCSIM_POLL_DUAL	(NFCSIM_POLL_INITIATOR | NFCSIM_POLL_TARGET)

struct nfcsim {
	struct nfc_dev *nfc_dev;

	struct mutex lock;

	struct delayed_work recv_work;

	struct sk_buff *clone_skb;

	struct delayed_work poll_work;
	u8 polling_mode;
	u8 curr_polling_mode;

	u8 shutting_down;

	u8 up;

	u8 initiator;

	data_exchange_cb_t cb;
	void *cb_context;

	struct nfcsim *peer_dev;
};

static struct nfcsim *dev0;
static struct nfcsim *dev1;

static struct workqueue_struct *wq;

static void nfcsim_cleanup_dev(struct nfcsim *dev, u8 shutdown)
{
	DEV_DBG(dev, "shutdown=%d\n", shutdown);

	mutex_lock(&dev->lock);

	dev->polling_mode = NFCSIM_POLL_NONE;
	dev->shutting_down = shutdown;
	dev->cb = NULL;
	dev_kfree_skb(dev->clone_skb);
	dev->clone_skb = NULL;

	mutex_unlock(&dev->lock);

	cancel_delayed_work_sync(&dev->poll_work);
	cancel_delayed_work_sync(&dev->recv_work);
}

static int nfcsim_target_found(struct nfcsim *dev)
{
	struct nfc_target nfc_tgt;

	DEV_DBG(dev, "\n");

	memset(&nfc_tgt, 0, sizeof(struct nfc_target));

	nfc_tgt.supported_protocols = NFC_PROTO_NFC_DEP_MASK;
	nfc_targets_found(dev->nfc_dev, &nfc_tgt, 1);

	return 0;
}

static int nfcsim_dev_up(struct nfc_dev *nfc_dev)
{
	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);

	DEV_DBG(dev, "\n");

	mutex_lock(&dev->lock);

	dev->up = 1;

	mutex_unlock(&dev->lock);

	return 0;
}

static int nfcsim_dev_down(struct nfc_dev *nfc_dev)
{
	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);

	DEV_DBG(dev, "\n");

	mutex_lock(&dev->lock);

	dev->up = 0;

	mutex_unlock(&dev->lock);

	return 0;
}

static int nfcsim_dep_link_up(struct nfc_dev *nfc_dev,
			      struct nfc_target *target,
			      u8 comm_mode, u8 *gb, size_t gb_len)
{
	int rc;
	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
	struct nfcsim *peer = dev->peer_dev;
	u8 *remote_gb;
	size_t remote_gb_len;

	DEV_DBG(dev, "target_idx: %d, comm_mode: %d\n", target->idx, comm_mode);

	mutex_lock(&peer->lock);

	nfc_tm_activated(peer->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
			 NFC_COMM_ACTIVE, gb, gb_len);

	remote_gb = nfc_get_local_general_bytes(peer->nfc_dev, &remote_gb_len);
	if (!remote_gb) {
		DEV_ERR(peer, "Can't get remote general bytes\n");

		mutex_unlock(&peer->lock);
		return -EINVAL;
	}

	mutex_unlock(&peer->lock);

	mutex_lock(&dev->lock);

	rc = nfc_set_remote_general_bytes(nfc_dev, remote_gb, remote_gb_len);
	if (rc) {
		DEV_ERR(dev, "Can't set remote general bytes\n");
		mutex_unlock(&dev->lock);
		return rc;
	}

	rc = nfc_dep_link_is_up(nfc_dev, target->idx, NFC_COMM_ACTIVE,
				NFC_RF_INITIATOR);

	mutex_unlock(&dev->lock);

	return rc;
}

static int nfcsim_dep_link_down(struct nfc_dev *nfc_dev)
{
	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);

	DEV_DBG(dev, "\n");

	nfcsim_cleanup_dev(dev, 0);

	return 0;
}

static int nfcsim_start_poll(struct nfc_dev *nfc_dev,
			     u32 im_protocols, u32 tm_protocols)
{
	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
	int rc;

	mutex_lock(&dev->lock);

	if (dev->polling_mode != NFCSIM_POLL_NONE) {
		DEV_ERR(dev, "Already in polling mode\n");
		rc = -EBUSY;
		goto exit;
	}

	if (im_protocols & NFC_PROTO_NFC_DEP_MASK)
		dev->polling_mode |= NFCSIM_POLL_INITIATOR;

	if (tm_protocols & NFC_PROTO_NFC_DEP_MASK)
		dev->polling_mode |= NFCSIM_POLL_TARGET;

	if (dev->polling_mode == NFCSIM_POLL_NONE) {
		DEV_ERR(dev, "Unsupported polling mode\n");
		rc = -EINVAL;
		goto exit;
	}

	dev->initiator = 0;
	dev->curr_polling_mode = NFCSIM_POLL_NONE;

	queue_delayed_work(wq, &dev->poll_work, 0);

	DEV_DBG(dev, "Start polling: im: 0x%X, tm: 0x%X\n", im_protocols,
		tm_protocols);

	rc = 0;
exit:
	mutex_unlock(&dev->lock);

	return rc;
}

static void nfcsim_stop_poll(struct nfc_dev *nfc_dev)
{
	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);

	DEV_DBG(dev, "Stop poll\n");

	mutex_lock(&dev->lock);

	dev->polling_mode = NFCSIM_POLL_NONE;

	mutex_unlock(&dev->lock);

	cancel_delayed_work_sync(&dev->poll_work);
}

static int nfcsim_activate_target(struct nfc_dev *nfc_dev,
				  struct nfc_target *target, u32 protocol)
{
	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);

	DEV_DBG(dev, "\n");

	return -ENOTSUPP;
}

static void nfcsim_deactivate_target(struct nfc_dev *nfc_dev,
				     struct nfc_target *target)
{
	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);

	DEV_DBG(dev, "\n");
}

static void nfcsim_wq_recv(struct work_struct *work)
{
	struct nfcsim *dev = container_of(work, struct nfcsim,
					  recv_work.work);

	mutex_lock(&dev->lock);

	if (dev->shutting_down || !dev->up || !dev->clone_skb) {
		dev_kfree_skb(dev->clone_skb);
		goto exit;
	}

	if (dev->initiator) {
		if (!dev->cb) {
			DEV_ERR(dev, "Null recv callback\n");
			dev_kfree_skb(dev->clone_skb);
			goto exit;
		}

		dev->cb(dev->cb_context, dev->clone_skb, 0);
		dev->cb = NULL;
	} else {
		nfc_tm_data_received(dev->nfc_dev, dev->clone_skb);
	}

exit:
	dev->clone_skb = NULL;

	mutex_unlock(&dev->lock);
}

static int nfcsim_tx(struct nfc_dev *nfc_dev, struct nfc_target *target,
		     struct sk_buff *skb, data_exchange_cb_t cb,
		     void *cb_context)
{
	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
	struct nfcsim *peer = dev->peer_dev;
	int err;

	mutex_lock(&dev->lock);

	if (dev->shutting_down || !dev->up) {
		mutex_unlock(&dev->lock);
		err = -ENODEV;
		goto exit;
	}

	dev->cb = cb;
	dev->cb_context = cb_context;

	mutex_unlock(&dev->lock);

	mutex_lock(&peer->lock);

	peer->clone_skb = skb_clone(skb, GFP_KERNEL);

	if (!peer->clone_skb) {
		DEV_ERR(dev, "skb_clone failed\n");
		mutex_unlock(&peer->lock);
		err = -ENOMEM;
		goto exit;
	}

	/* This simulates an arbitrary transmission delay between the 2 devices.
	 * If packet transmission occurs immediately between them, we have a
	 * non-stop flow of several tens of thousands SYMM packets per second
	 * and a burning cpu.
	 *
	 * TODO: Add support for a sysfs entry to control this delay.
	 */
	queue_delayed_work(wq, &peer->recv_work, msecs_to_jiffies(5));

	mutex_unlock(&peer->lock);

	err = 0;
exit:
	dev_kfree_skb(skb);

	return err;
}

static int nfcsim_im_transceive(struct nfc_dev *nfc_dev,
				struct nfc_target *target, struct sk_buff *skb,
				data_exchange_cb_t cb, void *cb_context)
{
	return nfcsim_tx(nfc_dev, target, skb, cb, cb_context);
}

static int nfcsim_tm_send(struct nfc_dev *nfc_dev, struct sk_buff *skb)
{
	return nfcsim_tx(nfc_dev, NULL, skb, NULL, NULL);
}

static struct nfc_ops nfcsim_nfc_ops = {
	.dev_up = nfcsim_dev_up,
	.dev_down = nfcsim_dev_down,
	.dep_link_up = nfcsim_dep_link_up,
	.dep_link_down = nfcsim_dep_link_down,
	.start_poll = nfcsim_start_poll,
	.stop_poll = nfcsim_stop_poll,
	.activate_target = nfcsim_activate_target,
	.deactivate_target = nfcsim_deactivate_target,
	.im_transceive = nfcsim_im_transceive,
	.tm_send = nfcsim_tm_send,
};

static void nfcsim_set_polling_mode(struct nfcsim *dev)
{
	if (dev->polling_mode == NFCSIM_POLL_NONE) {
		dev->curr_polling_mode = NFCSIM_POLL_NONE;
		return;
	}

	if (dev->curr_polling_mode == NFCSIM_POLL_NONE) {
		if (dev->polling_mode & NFCSIM_POLL_INITIATOR)
			dev->curr_polling_mode = NFCSIM_POLL_INITIATOR;
		else
			dev->curr_polling_mode = NFCSIM_POLL_TARGET;

		return;
	}

	if (dev->polling_mode == NFCSIM_POLL_DUAL) {
		if (dev->curr_polling_mode == NFCSIM_POLL_TARGET)
			dev->curr_polling_mode = NFCSIM_POLL_INITIATOR;
		else
			dev->curr_polling_mode = NFCSIM_POLL_TARGET;
	}
}

static void nfcsim_wq_poll(struct work_struct *work)
{
	struct nfcsim *dev = container_of(work, struct nfcsim, poll_work.work);
	struct nfcsim *peer = dev->peer_dev;

	/* These work items run on an ordered workqueue and are therefore
	 * serialized. So we can take both mutexes without being dead locked.
	 */
	mutex_lock(&dev->lock);
	mutex_lock(&peer->lock);

	nfcsim_set_polling_mode(dev);

	if (dev->curr_polling_mode == NFCSIM_POLL_NONE) {
		DEV_DBG(dev, "Not polling\n");
		goto unlock;
	}

	DEV_DBG(dev, "Polling as %s",
		dev->curr_polling_mode == NFCSIM_POLL_INITIATOR ?
		"initiator\n" : "target\n");

	if (dev->curr_polling_mode == NFCSIM_POLL_TARGET)
		goto sched_work;

	if (peer->curr_polling_mode == NFCSIM_POLL_TARGET) {
		peer->polling_mode = NFCSIM_POLL_NONE;
		dev->polling_mode = NFCSIM_POLL_NONE;

		dev->initiator = 1;

		nfcsim_target_found(dev);

		goto unlock;
	}

sched_work:
	/* This defines the delay for an initiator to check if the other device
	 * is polling in target mode.
	 * If the device starts in dual mode polling, it switches between
	 * initiator and target at every round.
	 * Because the wq is ordered and only 1 work item is executed at a time,
	 * we'll always have one device polling as initiator and the other as
	 * target at some point, even if both are started in dual mode.
	 */
	queue_delayed_work(wq, &dev->poll_work, msecs_to_jiffies(200));

unlock:
	mutex_unlock(&peer->lock);
	mutex_unlock(&dev->lock);
}

static struct nfcsim *nfcsim_init_dev(void)
{
	struct nfcsim *dev;
	int rc = -ENOMEM;

	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (dev == NULL)
		return ERR_PTR(-ENOMEM);

	mutex_init(&dev->lock);

	INIT_DELAYED_WORK(&dev->recv_work, nfcsim_wq_recv);
	INIT_DELAYED_WORK(&dev->poll_work, nfcsim_wq_poll);

	dev->nfc_dev = nfc_allocate_device(&nfcsim_nfc_ops,
					   NFC_PROTO_NFC_DEP_MASK,
					   0, 0);
	if (!dev->nfc_dev)
		goto error;

	nfc_set_drvdata(dev->nfc_dev, dev);

	rc = nfc_register_device(dev->nfc_dev);
	if (rc)
		goto free_nfc_dev;

	return dev;

free_nfc_dev:
	nfc_free_device(dev->nfc_dev);

error:
	kfree(dev);

	return ERR_PTR(rc);
}

static void nfcsim_free_device(struct nfcsim *dev)
{
	nfc_unregister_device(dev->nfc_dev);

	nfc_free_device(dev->nfc_dev);

	kfree(dev);
}

static int __init nfcsim_init(void)
{
	int rc;

	/* We need an ordered wq to ensure that poll_work items are executed
	 * one at a time.
	 */
	wq = alloc_ordered_workqueue("nfcsim", 0);
	if (!wq) {
		rc = -ENOMEM;
		goto exit;
	}

	dev0 = nfcsim_init_dev();
	if (IS_ERR(dev0)) {
		rc = PTR_ERR(dev0);
		goto exit;
	}

	dev1 = nfcsim_init_dev();
	if (IS_ERR(dev1)) {
		kfree(dev0);

		rc = PTR_ERR(dev1);
		goto exit;
	}

	dev0->peer_dev = dev1;
	dev1->peer_dev = dev0;

	pr_debug("NFCsim " NFCSIM_VERSION " initialized\n");

	rc = 0;
exit:
	if (rc)
		pr_err("Failed to initialize nfcsim driver (%d)\n",
		       rc);

	return rc;
}

static void __exit nfcsim_exit(void)
{
	nfcsim_cleanup_dev(dev0, 1);
	nfcsim_cleanup_dev(dev1, 1);

	nfcsim_free_device(dev0);
	nfcsim_free_device(dev1);

	destroy_workqueue(wq);
}

module_init(nfcsim_init);
module_exit(nfcsim_exit);

MODULE_DESCRIPTION("NFCSim driver ver " NFCSIM_VERSION);
MODULE_VERSION(NFCSIM_VERSION);
MODULE_LICENSE("GPL");
Commit	Line	Data
7cbe0ff3 TE	1	/*
	2	* NFC hardware simulation driver
	3	* Copyright (c) 2013, Intel Corporation.
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms and conditions of the GNU General Public License,
	7	* version 2, as published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	*/
	15
	16	#include <linux/device.h>
	17	#include <linux/kernel.h>
	18	#include <linux/module.h>
	19	#include <linux/nfc.h>
	20	#include <net/nfc/nfc.h>
	21
073a625f	22	#define DEV_ERR(_dev, fmt, args...) nfc_err(&_dev->nfc_dev->dev, \
7cbe0ff3 TE	23	"%s: " fmt, __func__, ## args)
7cbe0ff3 TE	24
b4834839	25	#define DEV_DBG(_dev, fmt, args...) dev_dbg(&_dev->nfc_dev->dev, \
7cbe0ff3 TE	26	"%s: " fmt, __func__, ## args)
	27
	28	#define NFCSIM_VERSION "0.1"
	29
	30	#define NFCSIM_POLL_NONE 0
	31	#define NFCSIM_POLL_INITIATOR 1
	32	#define NFCSIM_POLL_TARGET 2
	33	#define NFCSIM_POLL_DUAL (NFCSIM_POLL_INITIATOR \| NFCSIM_POLL_TARGET)
	34
	35	struct nfcsim {
	36	struct nfc_dev *nfc_dev;
	37
	38	struct mutex lock;
	39
	40	struct delayed_work recv_work;
	41
	42	struct sk_buff *clone_skb;
	43
	44	struct delayed_work poll_work;
	45	u8 polling_mode;
	46	u8 curr_polling_mode;
	47
	48	u8 shutting_down;
	49
	50	u8 up;
	51
	52	u8 initiator;
	53
	54	data_exchange_cb_t cb;
	55	void *cb_context;
	56
	57	struct nfcsim *peer_dev;
	58	};
	59
	60	static struct nfcsim *dev0;
	61	static struct nfcsim *dev1;
	62
40dac370	63	static struct workqueue_struct *wq;
7cbe0ff3 TE	64
	65	static void nfcsim_cleanup_dev(struct nfcsim *dev, u8 shutdown)
	66	{
b4834839	67	DEV_DBG(dev, "shutdown=%d\n", shutdown);
7cbe0ff3 TE	68
	69	mutex_lock(&dev->lock);
	70
	71	dev->polling_mode = NFCSIM_POLL_NONE;
	72	dev->shutting_down = shutdown;
	73	dev->cb = NULL;
	74	dev_kfree_skb(dev->clone_skb);
	75	dev->clone_skb = NULL;
	76
	77	mutex_unlock(&dev->lock);
	78
	79	cancel_delayed_work_sync(&dev->poll_work);
	80	cancel_delayed_work_sync(&dev->recv_work);
	81	}
	82
	83	static int nfcsim_target_found(struct nfcsim *dev)
	84	{
	85	struct nfc_target nfc_tgt;
	86
b4834839	87	DEV_DBG(dev, "\n");
7cbe0ff3 TE	88
	89	memset(&nfc_tgt, 0, sizeof(struct nfc_target));
	90
	91	nfc_tgt.supported_protocols = NFC_PROTO_NFC_DEP_MASK;
	92	nfc_targets_found(dev->nfc_dev, &nfc_tgt, 1);
	93
	94	return 0;
	95	}
	96
	97	static int nfcsim_dev_up(struct nfc_dev *nfc_dev)
	98	{
	99	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
	100
b4834839	101	DEV_DBG(dev, "\n");
7cbe0ff3 TE	102
	103	mutex_lock(&dev->lock);
	104
	105	dev->up = 1;
	106
	107	mutex_unlock(&dev->lock);
	108
	109	return 0;
	110	}
	111
	112	static int nfcsim_dev_down(struct nfc_dev *nfc_dev)
	113	{
	114	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
	115
b4834839	116	DEV_DBG(dev, "\n");
7cbe0ff3 TE	117
	118	mutex_lock(&dev->lock);
	119
	120	dev->up = 0;
	121
	122	mutex_unlock(&dev->lock);
	123
	124	return 0;
	125	}
	126
	127	static int nfcsim_dep_link_up(struct nfc_dev *nfc_dev,
	128	struct nfc_target *target,
	129	u8 comm_mode, u8 *gb, size_t gb_len)
	130	{
	131	int rc;
	132	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
	133	struct nfcsim *peer = dev->peer_dev;
	134	u8 *remote_gb;
	135	size_t remote_gb_len;
	136
	137	DEV_DBG(dev, "target_idx: %d, comm_mode: %d\n", target->idx, comm_mode);
	138
	139	mutex_lock(&peer->lock);
	140
	141	nfc_tm_activated(peer->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
	142	NFC_COMM_ACTIVE, gb, gb_len);
	143
	144	remote_gb = nfc_get_local_general_bytes(peer->nfc_dev, &remote_gb_len);
	145	if (!remote_gb) {
073a625f	146	DEV_ERR(peer, "Can't get remote general bytes\n");
7cbe0ff3 TE	147
	148	mutex_unlock(&peer->lock);
	149	return -EINVAL;
	150	}
	151
	152	mutex_unlock(&peer->lock);
	153
	154	mutex_lock(&dev->lock);
	155
	156	rc = nfc_set_remote_general_bytes(nfc_dev, remote_gb, remote_gb_len);
	157	if (rc) {
073a625f	158	DEV_ERR(dev, "Can't set remote general bytes\n");
7cbe0ff3 TE	159	mutex_unlock(&dev->lock);
	160	return rc;
	161	}
	162
	163	rc = nfc_dep_link_is_up(nfc_dev, target->idx, NFC_COMM_ACTIVE,
	164	NFC_RF_INITIATOR);
	165
	166	mutex_unlock(&dev->lock);
	167
	168	return rc;
	169	}
	170
	171	static int nfcsim_dep_link_down(struct nfc_dev *nfc_dev)
	172	{
	173	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
	174
b4834839	175	DEV_DBG(dev, "\n");
7cbe0ff3 TE	176
	177	nfcsim_cleanup_dev(dev, 0);
	178
	179	return 0;
	180	}
	181
	182	static int nfcsim_start_poll(struct nfc_dev *nfc_dev,
	183	u32 im_protocols, u32 tm_protocols)
	184	{
	185	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
	186	int rc;
	187
	188	mutex_lock(&dev->lock);
	189
	190	if (dev->polling_mode != NFCSIM_POLL_NONE) {
073a625f	191	DEV_ERR(dev, "Already in polling mode\n");
7cbe0ff3 TE	192	rc = -EBUSY;
	193	goto exit;
	194	}
	195
	196	if (im_protocols & NFC_PROTO_NFC_DEP_MASK)
	197	dev->polling_mode \|= NFCSIM_POLL_INITIATOR;
	198
	199	if (tm_protocols & NFC_PROTO_NFC_DEP_MASK)
	200	dev->polling_mode \|= NFCSIM_POLL_TARGET;
	201
	202	if (dev->polling_mode == NFCSIM_POLL_NONE) {
073a625f	203	DEV_ERR(dev, "Unsupported polling mode\n");
7cbe0ff3 TE	204	rc = -EINVAL;
	205	goto exit;
	206	}
	207
	208	dev->initiator = 0;
	209	dev->curr_polling_mode = NFCSIM_POLL_NONE;
	210
	211	queue_delayed_work(wq, &dev->poll_work, 0);
	212
b4834839	213	DEV_DBG(dev, "Start polling: im: 0x%X, tm: 0x%X\n", im_protocols,
7cbe0ff3 TE	214	tm_protocols);
	215
	216	rc = 0;
	217	exit:
	218	mutex_unlock(&dev->lock);
	219
	220	return rc;
	221	}
	222
	223	static void nfcsim_stop_poll(struct nfc_dev *nfc_dev)
	224	{
	225	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
	226
b4834839	227	DEV_DBG(dev, "Stop poll\n");
7cbe0ff3 TE	228
	229	mutex_lock(&dev->lock);
	230
	231	dev->polling_mode = NFCSIM_POLL_NONE;
	232
	233	mutex_unlock(&dev->lock);
	234
	235	cancel_delayed_work_sync(&dev->poll_work);
	236	}
	237
	238	static int nfcsim_activate_target(struct nfc_dev *nfc_dev,
	239	struct nfc_target *target, u32 protocol)
	240	{
	241	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
	242
b4834839	243	DEV_DBG(dev, "\n");
7cbe0ff3 TE	244
	245	return -ENOTSUPP;
	246	}
	247
	248	static void nfcsim_deactivate_target(struct nfc_dev *nfc_dev,
	249	struct nfc_target *target)
	250	{
	251	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
	252
b4834839	253	DEV_DBG(dev, "\n");
7cbe0ff3 TE	254	}
	255
	256	static void nfcsim_wq_recv(struct work_struct *work)
	257	{
	258	struct nfcsim *dev = container_of(work, struct nfcsim,
	259	recv_work.work);
	260
	261	mutex_lock(&dev->lock);
	262
	263	if (dev->shutting_down \|\| !dev->up \|\| !dev->clone_skb) {
	264	dev_kfree_skb(dev->clone_skb);
	265	goto exit;
	266	}
	267
	268	if (dev->initiator) {
	269	if (!dev->cb) {
073a625f	270	DEV_ERR(dev, "Null recv callback\n");
7cbe0ff3 TE	271	dev_kfree_skb(dev->clone_skb);
	272	goto exit;
	273	}
	274
	275	dev->cb(dev->cb_context, dev->clone_skb, 0);
	276	dev->cb = NULL;
	277	} else {
	278	nfc_tm_data_received(dev->nfc_dev, dev->clone_skb);
	279	}
	280
	281	exit:
	282	dev->clone_skb = NULL;
	283
	284	mutex_unlock(&dev->lock);
	285	}
	286
	287	static int nfcsim_tx(struct nfc_dev nfc_dev, struct nfc_target target,
	288	struct sk_buff *skb, data_exchange_cb_t cb,
	289	void *cb_context)
	290	{
	291	struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
	292	struct nfcsim *peer = dev->peer_dev;
	293	int err;
	294
	295	mutex_lock(&dev->lock);
	296
	297	if (dev->shutting_down \|\| !dev->up) {
	298	mutex_unlock(&dev->lock);
	299	err = -ENODEV;
	300	goto exit;
	301	}
	302
	303	dev->cb = cb;
	304	dev->cb_context = cb_context;
	305
	306	mutex_unlock(&dev->lock);
	307
	308	mutex_lock(&peer->lock);
	309
	310	peer->clone_skb = skb_clone(skb, GFP_KERNEL);
	311
	312	if (!peer->clone_skb) {
073a625f	313	DEV_ERR(dev, "skb_clone failed\n");
7cbe0ff3 TE	314	mutex_unlock(&peer->lock);
	315	err = -ENOMEM;
	316	goto exit;
	317	}
	318
	319	/* This simulates an arbitrary transmission delay between the 2 devices.
	320	* If packet transmission occurs immediately between them, we have a
	321	* non-stop flow of several tens of thousands SYMM packets per second
	322	* and a burning cpu.
	323	*
	324	* TODO: Add support for a sysfs entry to control this delay.
	325	*/
	326	queue_delayed_work(wq, &peer->recv_work, msecs_to_jiffies(5));
	327
	328	mutex_unlock(&peer->lock);
	329
	330	err = 0;
	331	exit:
	332	dev_kfree_skb(skb);
	333
	334	return err;
	335	}
	336
	337	static int nfcsim_im_transceive(struct nfc_dev *nfc_dev,
	338	struct nfc_target target, struct sk_buff skb,
	339	data_exchange_cb_t cb, void *cb_context)
	340	{
	341	return nfcsim_tx(nfc_dev, target, skb, cb, cb_context);
	342	}
	343
	344	static int nfcsim_tm_send(struct nfc_dev nfc_dev, struct sk_buff skb)
	345	{
	346	return nfcsim_tx(nfc_dev, NULL, skb, NULL, NULL);
	347	}
	348
	349	static struct nfc_ops nfcsim_nfc_ops = {
	350	.dev_up = nfcsim_dev_up,
	351	.dev_down = nfcsim_dev_down,
	352	.dep_link_up = nfcsim_dep_link_up,
	353	.dep_link_down = nfcsim_dep_link_down,
	354	.start_poll = nfcsim_start_poll,
	355	.stop_poll = nfcsim_stop_poll,
	356	.activate_target = nfcsim_activate_target,
	357	.deactivate_target = nfcsim_deactivate_target,
	358	.im_transceive = nfcsim_im_transceive,
	359	.tm_send = nfcsim_tm_send,
	360	};
	361
	362	static void nfcsim_set_polling_mode(struct nfcsim *dev)
	363	{
	364	if (dev->polling_mode == NFCSIM_POLL_NONE) {
	365	dev->curr_polling_mode = NFCSIM_POLL_NONE;
	366	return;
	367	}
	368
	369	if (dev->curr_polling_mode == NFCSIM_POLL_NONE) {
	370	if (dev->polling_mode & NFCSIM_POLL_INITIATOR)
	371	dev->curr_polling_mode = NFCSIM_POLL_INITIATOR;
	372	else
	373	dev->curr_polling_mode = NFCSIM_POLL_TARGET;
	374
	375	return;
	376	}
	377
378	if (dev->polling_mode == NFCSIM_POLL_DUAL) {
379	if (dev->curr_polling_mode == NFCSIM_POLL_TARGET)
380	dev->curr_polling_mode = NFCSIM_POLL_INITIATOR;
381	else
382	dev->curr_polling_mode = NFCSIM_POLL_TARGET;
383	}
384	}
385
386	static void nfcsim_wq_poll(struct work_struct *work)
387	{
388	struct nfcsim *dev = container_of(work, struct nfcsim, poll_work.work);
389	struct nfcsim *peer = dev->peer_dev;
390
391	/* These work items run on an ordered workqueue and are therefore
392	* serialized. So we can take both mutexes without being dead locked.
393	*/
394	mutex_lock(&dev->lock);
395	mutex_lock(&peer->lock);
396
397	nfcsim_set_polling_mode(dev);
398
399	if (dev->curr_polling_mode == NFCSIM_POLL_NONE) {
b4834839	400	DEV_DBG(dev, "Not polling\n");
7cbe0ff3 TE	401	goto unlock;
	402	}
	403
	404	DEV_DBG(dev, "Polling as %s",
	405	dev->curr_polling_mode == NFCSIM_POLL_INITIATOR ?
b4834839	406	"initiator\n" : "target\n");
7cbe0ff3 TE	407
	408	if (dev->curr_polling_mode == NFCSIM_POLL_TARGET)
	409	goto sched_work;
	410
	411	if (peer->curr_polling_mode == NFCSIM_POLL_TARGET) {
	412	peer->polling_mode = NFCSIM_POLL_NONE;
	413	dev->polling_mode = NFCSIM_POLL_NONE;
	414
	415	dev->initiator = 1;
	416
	417	nfcsim_target_found(dev);
	418
	419	goto unlock;
	420	}
	421
	422	sched_work:
	423	/* This defines the delay for an initiator to check if the other device
	424	* is polling in target mode.
	425	* If the device starts in dual mode polling, it switches between
	426	* initiator and target at every round.
	427	* Because the wq is ordered and only 1 work item is executed at a time,
	428	* we'll always have one device polling as initiator and the other as
	429	* target at some point, even if both are started in dual mode.
	430	*/
	431	queue_delayed_work(wq, &dev->poll_work, msecs_to_jiffies(200));
	432
	433	unlock:
	434	mutex_unlock(&peer->lock);
	435	mutex_unlock(&dev->lock);
	436	}
	437
	438	static struct nfcsim *nfcsim_init_dev(void)
	439	{
	440	struct nfcsim *dev;
	441	int rc = -ENOMEM;
	442
	443	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	444	if (dev == NULL)
	445	return ERR_PTR(-ENOMEM);
	446
	447	mutex_init(&dev->lock);
	448
	449	INIT_DELAYED_WORK(&dev->recv_work, nfcsim_wq_recv);
	450	INIT_DELAYED_WORK(&dev->poll_work, nfcsim_wq_poll);
	451
	452	dev->nfc_dev = nfc_allocate_device(&nfcsim_nfc_ops,
	453	NFC_PROTO_NFC_DEP_MASK,
	454	0, 0);
	455	if (!dev->nfc_dev)
	456	goto error;
	457
	458	nfc_set_drvdata(dev->nfc_dev, dev);
	459
	460	rc = nfc_register_device(dev->nfc_dev);
	461	if (rc)
	462	goto free_nfc_dev;
	463
	464	return dev;
	465
	466	free_nfc_dev:
	467	nfc_free_device(dev->nfc_dev);
	468
	469	error:
	470	kfree(dev);
471
472	return ERR_PTR(rc);
473	}
474
475	static void nfcsim_free_device(struct nfcsim *dev)
476	{
477	nfc_unregister_device(dev->nfc_dev);
478
479	nfc_free_device(dev->nfc_dev);
480
481	kfree(dev);
482	}
483
40dac370	484	static int __init nfcsim_init(void)
7cbe0ff3 TE	485	{
	486	int rc;
	487
	488	/* We need an ordered wq to ensure that poll_work items are executed
	489	* one at a time.
	490	*/
	491	wq = alloc_ordered_workqueue("nfcsim", 0);
	492	if (!wq) {
	493	rc = -ENOMEM;
	494	goto exit;
	495	}
	496
	497	dev0 = nfcsim_init_dev();
	498	if (IS_ERR(dev0)) {
	499	rc = PTR_ERR(dev0);
	500	goto exit;
	501	}
	502
	503	dev1 = nfcsim_init_dev();
	504	if (IS_ERR(dev1)) {
	505	kfree(dev0);
	506
	507	rc = PTR_ERR(dev1);
	508	goto exit;
	509	}
	510
	511	dev0->peer_dev = dev1;
	512	dev1->peer_dev = dev0;
	513
	514	pr_debug("NFCsim " NFCSIM_VERSION " initialized\n");
	515
	516	rc = 0;
	517	exit:
	518	if (rc)
	519	pr_err("Failed to initialize nfcsim driver (%d)\n",
	520	rc);
	521
	522	return rc;
	523	}
	524
40dac370	525	static void __exit nfcsim_exit(void)
7cbe0ff3 TE	526	{
	527	nfcsim_cleanup_dev(dev0, 1);
	528	nfcsim_cleanup_dev(dev1, 1);
	529
	530	nfcsim_free_device(dev0);
	531	nfcsim_free_device(dev1);
	532
	533	destroy_workqueue(wq);
	534	}
	535
	536	module_init(nfcsim_init);
	537	module_exit(nfcsim_exit);
	538
	539	MODULE_DESCRIPTION("NFCSim driver ver " NFCSIM_VERSION);
	540	MODULE_VERSION(NFCSIM_VERSION);
	541	MODULE_LICENSE("GPL");