summaryrefslogtreecommitdiffstats
path: root/drivers/nfc/nfcsim.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:49:45 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:49:45 +0000
commit2c3c1048746a4622d8c89a29670120dc8fab93c4 (patch)
tree848558de17fb3008cdf4d861b01ac7781903ce39 /drivers/nfc/nfcsim.c
parentInitial commit. (diff)
downloadlinux-2c3c1048746a4622d8c89a29670120dc8fab93c4.tar.xz
linux-2c3c1048746a4622d8c89a29670120dc8fab93c4.zip
Adding upstream version 6.1.76.upstream/6.1.76upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--drivers/nfc/nfcsim.c500
1 files changed, 500 insertions, 0 deletions
diff --git a/drivers/nfc/nfcsim.c b/drivers/nfc/nfcsim.c
new file mode 100644
index 000000000..0f6befe8b
--- /dev/null
+++ b/drivers/nfc/nfcsim.c
@@ -0,0 +1,500 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * NFC hardware simulation driver
+ * Copyright (c) 2013, Intel Corporation.
+ */
+
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/ctype.h>
+#include <linux/debugfs.h>
+#include <linux/nfc.h>
+#include <net/nfc/nfc.h>
+#include <net/nfc/digital.h>
+
+#define NFCSIM_ERR(d, fmt, args...) nfc_err(&d->nfc_digital_dev->nfc_dev->dev, \
+ "%s: " fmt, __func__, ## args)
+
+#define NFCSIM_DBG(d, fmt, args...) dev_dbg(&d->nfc_digital_dev->nfc_dev->dev, \
+ "%s: " fmt, __func__, ## args)
+
+#define NFCSIM_VERSION "0.2"
+
+#define NFCSIM_MODE_NONE 0
+#define NFCSIM_MODE_INITIATOR 1
+#define NFCSIM_MODE_TARGET 2
+
+#define NFCSIM_CAPABILITIES (NFC_DIGITAL_DRV_CAPS_IN_CRC | \
+ NFC_DIGITAL_DRV_CAPS_TG_CRC)
+
+struct nfcsim {
+ struct nfc_digital_dev *nfc_digital_dev;
+
+ struct work_struct recv_work;
+ struct delayed_work send_work;
+
+ struct nfcsim_link *link_in;
+ struct nfcsim_link *link_out;
+
+ bool up;
+ u8 mode;
+ u8 rf_tech;
+
+ u16 recv_timeout;
+
+ nfc_digital_cmd_complete_t cb;
+ void *arg;
+
+ u8 dropframe;
+};
+
+struct nfcsim_link {
+ struct mutex lock;
+
+ u8 rf_tech;
+ u8 mode;
+
+ u8 shutdown;
+
+ struct sk_buff *skb;
+ wait_queue_head_t recv_wait;
+ u8 cond;
+};
+
+static struct nfcsim_link *nfcsim_link_new(void)
+{
+ struct nfcsim_link *link;
+
+ link = kzalloc(sizeof(struct nfcsim_link), GFP_KERNEL);
+ if (!link)
+ return NULL;
+
+ mutex_init(&link->lock);
+ init_waitqueue_head(&link->recv_wait);
+
+ return link;
+}
+
+static void nfcsim_link_free(struct nfcsim_link *link)
+{
+ dev_kfree_skb(link->skb);
+ kfree(link);
+}
+
+static void nfcsim_link_recv_wake(struct nfcsim_link *link)
+{
+ link->cond = 1;
+ wake_up_interruptible(&link->recv_wait);
+}
+
+static void nfcsim_link_set_skb(struct nfcsim_link *link, struct sk_buff *skb,
+ u8 rf_tech, u8 mode)
+{
+ mutex_lock(&link->lock);
+
+ dev_kfree_skb(link->skb);
+ link->skb = skb;
+ link->rf_tech = rf_tech;
+ link->mode = mode;
+
+ mutex_unlock(&link->lock);
+}
+
+static void nfcsim_link_recv_cancel(struct nfcsim_link *link)
+{
+ mutex_lock(&link->lock);
+
+ link->mode = NFCSIM_MODE_NONE;
+
+ mutex_unlock(&link->lock);
+
+ nfcsim_link_recv_wake(link);
+}
+
+static void nfcsim_link_shutdown(struct nfcsim_link *link)
+{
+ mutex_lock(&link->lock);
+
+ link->shutdown = 1;
+ link->mode = NFCSIM_MODE_NONE;
+
+ mutex_unlock(&link->lock);
+
+ nfcsim_link_recv_wake(link);
+}
+
+static struct sk_buff *nfcsim_link_recv_skb(struct nfcsim_link *link,
+ int timeout, u8 rf_tech, u8 mode)
+{
+ int rc;
+ struct sk_buff *skb;
+
+ rc = wait_event_interruptible_timeout(link->recv_wait,
+ link->cond,
+ msecs_to_jiffies(timeout));
+
+ mutex_lock(&link->lock);
+
+ skb = link->skb;
+ link->skb = NULL;
+
+ if (!rc) {
+ rc = -ETIMEDOUT;
+ goto done;
+ }
+
+ if (!skb || link->rf_tech != rf_tech || link->mode == mode) {
+ rc = -EINVAL;
+ goto done;
+ }
+
+ if (link->shutdown) {
+ rc = -ENODEV;
+ goto done;
+ }
+
+done:
+ mutex_unlock(&link->lock);
+
+ if (rc < 0) {
+ dev_kfree_skb(skb);
+ skb = ERR_PTR(rc);
+ }
+
+ link->cond = 0;
+
+ return skb;
+}
+
+static void nfcsim_send_wq(struct work_struct *work)
+{
+ struct nfcsim *dev = container_of(work, struct nfcsim, send_work.work);
+
+ /*
+ * To effectively send data, the device just wake up its link_out which
+ * is the link_in of the peer device. The exchanged skb has already been
+ * stored in the dev->link_out through nfcsim_link_set_skb().
+ */
+ nfcsim_link_recv_wake(dev->link_out);
+}
+
+static void nfcsim_recv_wq(struct work_struct *work)
+{
+ struct nfcsim *dev = container_of(work, struct nfcsim, recv_work);
+ struct sk_buff *skb;
+
+ skb = nfcsim_link_recv_skb(dev->link_in, dev->recv_timeout,
+ dev->rf_tech, dev->mode);
+
+ if (!dev->up) {
+ NFCSIM_ERR(dev, "Device is down\n");
+
+ if (!IS_ERR(skb))
+ dev_kfree_skb(skb);
+ return;
+ }
+
+ dev->cb(dev->nfc_digital_dev, dev->arg, skb);
+}
+
+static int nfcsim_send(struct nfc_digital_dev *ddev, struct sk_buff *skb,
+ u16 timeout, nfc_digital_cmd_complete_t cb, void *arg)
+{
+ struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
+ u8 delay;
+
+ if (!dev->up) {
+ NFCSIM_ERR(dev, "Device is down\n");
+ return -ENODEV;
+ }
+
+ dev->recv_timeout = timeout;
+ dev->cb = cb;
+ dev->arg = arg;
+
+ schedule_work(&dev->recv_work);
+
+ if (dev->dropframe) {
+ NFCSIM_DBG(dev, "dropping frame (out of %d)\n", dev->dropframe);
+ dev_kfree_skb(skb);
+ dev->dropframe--;
+
+ return 0;
+ }
+
+ if (skb) {
+ nfcsim_link_set_skb(dev->link_out, skb, dev->rf_tech,
+ dev->mode);
+
+ /* Add random delay (between 3 and 10 ms) before sending data */
+ get_random_bytes(&delay, 1);
+ delay = 3 + (delay & 0x07);
+
+ schedule_delayed_work(&dev->send_work, msecs_to_jiffies(delay));
+ }
+
+ return 0;
+}
+
+static void nfcsim_abort_cmd(struct nfc_digital_dev *ddev)
+{
+ const struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
+
+ nfcsim_link_recv_cancel(dev->link_in);
+}
+
+static int nfcsim_switch_rf(struct nfc_digital_dev *ddev, bool on)
+{
+ struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
+
+ dev->up = on;
+
+ return 0;
+}
+
+static int nfcsim_in_configure_hw(struct nfc_digital_dev *ddev,
+ int type, int param)
+{
+ struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
+
+ switch (type) {
+ case NFC_DIGITAL_CONFIG_RF_TECH:
+ dev->up = true;
+ dev->mode = NFCSIM_MODE_INITIATOR;
+ dev->rf_tech = param;
+ break;
+
+ case NFC_DIGITAL_CONFIG_FRAMING:
+ break;
+
+ default:
+ NFCSIM_ERR(dev, "Invalid configuration type: %d\n", type);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int nfcsim_in_send_cmd(struct nfc_digital_dev *ddev,
+ struct sk_buff *skb, u16 timeout,
+ nfc_digital_cmd_complete_t cb, void *arg)
+{
+ return nfcsim_send(ddev, skb, timeout, cb, arg);
+}
+
+static int nfcsim_tg_configure_hw(struct nfc_digital_dev *ddev,
+ int type, int param)
+{
+ struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
+
+ switch (type) {
+ case NFC_DIGITAL_CONFIG_RF_TECH:
+ dev->up = true;
+ dev->mode = NFCSIM_MODE_TARGET;
+ dev->rf_tech = param;
+ break;
+
+ case NFC_DIGITAL_CONFIG_FRAMING:
+ break;
+
+ default:
+ NFCSIM_ERR(dev, "Invalid configuration type: %d\n", type);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int nfcsim_tg_send_cmd(struct nfc_digital_dev *ddev,
+ struct sk_buff *skb, u16 timeout,
+ nfc_digital_cmd_complete_t cb, void *arg)
+{
+ return nfcsim_send(ddev, skb, timeout, cb, arg);
+}
+
+static int nfcsim_tg_listen(struct nfc_digital_dev *ddev, u16 timeout,
+ nfc_digital_cmd_complete_t cb, void *arg)
+{
+ return nfcsim_send(ddev, NULL, timeout, cb, arg);
+}
+
+static const struct nfc_digital_ops nfcsim_digital_ops = {
+ .in_configure_hw = nfcsim_in_configure_hw,
+ .in_send_cmd = nfcsim_in_send_cmd,
+
+ .tg_listen = nfcsim_tg_listen,
+ .tg_configure_hw = nfcsim_tg_configure_hw,
+ .tg_send_cmd = nfcsim_tg_send_cmd,
+
+ .abort_cmd = nfcsim_abort_cmd,
+ .switch_rf = nfcsim_switch_rf,
+};
+
+static struct dentry *nfcsim_debugfs_root;
+
+static void nfcsim_debugfs_init(void)
+{
+ nfcsim_debugfs_root = debugfs_create_dir("nfcsim", NULL);
+}
+
+static void nfcsim_debugfs_remove(void)
+{
+ debugfs_remove_recursive(nfcsim_debugfs_root);
+}
+
+static void nfcsim_debugfs_init_dev(struct nfcsim *dev)
+{
+ struct dentry *dev_dir;
+ char devname[5]; /* nfcX\0 */
+ u32 idx;
+ int n;
+
+ if (!nfcsim_debugfs_root) {
+ NFCSIM_ERR(dev, "nfcsim debugfs not initialized\n");
+ return;
+ }
+
+ idx = dev->nfc_digital_dev->nfc_dev->idx;
+ n = snprintf(devname, sizeof(devname), "nfc%d", idx);
+ if (n >= sizeof(devname)) {
+ NFCSIM_ERR(dev, "Could not compute dev name for dev %d\n", idx);
+ return;
+ }
+
+ dev_dir = debugfs_create_dir(devname, nfcsim_debugfs_root);
+ if (!dev_dir) {
+ NFCSIM_ERR(dev, "Could not create debugfs entries for nfc%d\n",
+ idx);
+ return;
+ }
+
+ debugfs_create_u8("dropframe", 0664, dev_dir, &dev->dropframe);
+}
+
+static struct nfcsim *nfcsim_device_new(struct nfcsim_link *link_in,
+ struct nfcsim_link *link_out)
+{
+ struct nfcsim *dev;
+ int rc;
+
+ dev = kzalloc(sizeof(struct nfcsim), GFP_KERNEL);
+ if (!dev)
+ return ERR_PTR(-ENOMEM);
+
+ INIT_DELAYED_WORK(&dev->send_work, nfcsim_send_wq);
+ INIT_WORK(&dev->recv_work, nfcsim_recv_wq);
+
+ dev->nfc_digital_dev =
+ nfc_digital_allocate_device(&nfcsim_digital_ops,
+ NFC_PROTO_NFC_DEP_MASK,
+ NFCSIM_CAPABILITIES,
+ 0, 0);
+ if (!dev->nfc_digital_dev) {
+ kfree(dev);
+ return ERR_PTR(-ENOMEM);
+ }
+
+ nfc_digital_set_drvdata(dev->nfc_digital_dev, dev);
+
+ dev->link_in = link_in;
+ dev->link_out = link_out;
+
+ rc = nfc_digital_register_device(dev->nfc_digital_dev);
+ if (rc) {
+ pr_err("Could not register digital device (%d)\n", rc);
+ nfc_digital_free_device(dev->nfc_digital_dev);
+ kfree(dev);
+
+ return ERR_PTR(rc);
+ }
+
+ nfcsim_debugfs_init_dev(dev);
+
+ return dev;
+}
+
+static void nfcsim_device_free(struct nfcsim *dev)
+{
+ nfc_digital_unregister_device(dev->nfc_digital_dev);
+
+ dev->up = false;
+
+ nfcsim_link_shutdown(dev->link_in);
+
+ cancel_delayed_work_sync(&dev->send_work);
+ cancel_work_sync(&dev->recv_work);
+
+ nfc_digital_free_device(dev->nfc_digital_dev);
+
+ kfree(dev);
+}
+
+static struct nfcsim *dev0;
+static struct nfcsim *dev1;
+
+static int __init nfcsim_init(void)
+{
+ struct nfcsim_link *link0, *link1;
+ int rc;
+
+ link0 = nfcsim_link_new();
+ link1 = nfcsim_link_new();
+ if (!link0 || !link1) {
+ rc = -ENOMEM;
+ goto exit_err;
+ }
+
+ nfcsim_debugfs_init();
+
+ dev0 = nfcsim_device_new(link0, link1);
+ if (IS_ERR(dev0)) {
+ rc = PTR_ERR(dev0);
+ goto exit_err;
+ }
+
+ dev1 = nfcsim_device_new(link1, link0);
+ if (IS_ERR(dev1)) {
+ nfcsim_device_free(dev0);
+
+ rc = PTR_ERR(dev1);
+ goto exit_err;
+ }
+
+ pr_info("nfcsim " NFCSIM_VERSION " initialized\n");
+
+ return 0;
+
+exit_err:
+ pr_err("Failed to initialize nfcsim driver (%d)\n", rc);
+
+ if (link0)
+ nfcsim_link_free(link0);
+ if (link1)
+ nfcsim_link_free(link1);
+
+ return rc;
+}
+
+static void __exit nfcsim_exit(void)
+{
+ struct nfcsim_link *link0, *link1;
+
+ link0 = dev0->link_in;
+ link1 = dev0->link_out;
+
+ nfcsim_device_free(dev0);
+ nfcsim_device_free(dev1);
+
+ nfcsim_link_free(link0);
+ nfcsim_link_free(link1);
+
+ nfcsim_debugfs_remove();
+}
+
+module_init(nfcsim_init);
+module_exit(nfcsim_exit);
+
+MODULE_DESCRIPTION("NFCSim driver ver " NFCSIM_VERSION);
+MODULE_VERSION(NFCSIM_VERSION);
+MODULE_LICENSE("GPL");