rollup driver simplification

crypto/Kconfig

@@ -1038,16 +1038,6 @@ config CRYPTO_SHA3
 	help
 	  SHA-3 secure hash algorithms (FIPS 202, ISO/IEC 10118-3)
 
-config CRYPTO_KECCAK
-	tristate "KECCAK digest algorithm"
-	select CRYPTO_HASH
-    depends on CRYPTO_SHA3
-	help
-	  It's based on cryptographic sponge function family called Keccak.
-
-	  References:
-	  http://keccak.noekeon.org/
-
 config CRYPTO_SM3
 	tristate
 

crypto/sha3_generic.c

@@ -237,35 +237,6 @@ int crypto_sha3_final(struct shash_desc *desc, u8 *out)
 }
 EXPORT_SYMBOL(crypto_sha3_final);
 
-#ifdef CONFIG_CRYPTO_KECCAK
-int crypto_keccak_final(struct shash_desc *desc, u8 *out)
-{
-	struct sha3_state *sctx = shash_desc_ctx(desc);
-	unsigned int i, inlen = sctx->partial;
-	unsigned int digest_size = crypto_shash_digestsize(desc->tfm);
-	__le64 *digest = (__le64 *)out;
-
-	sctx->buf[inlen++] = 0x01;
-	memset(sctx->buf + inlen, 0, sctx->rsiz - inlen);
-	sctx->buf[sctx->rsiz - 1] |= 0x80;
-
-	for (i = 0; i < sctx->rsizw; i++)
-		sctx->st[i] ^= get_unaligned_le64(sctx->buf + 8 * i);
-
-	keccakf(sctx->st);
-
-	for (i = 0; i < digest_size / 8; i++)
-		put_unaligned_le64(sctx->st[i], digest++);
-
-	if (digest_size & 4)
-		put_unaligned_le32(sctx->st[i], (__le32 *)digest);
-
-	memset(sctx, 0, sizeof(*sctx));
-	return 0;
-}
-EXPORT_SYMBOL(crypto_keccak_final);
-#endif
-
 static struct shash_alg algs[] = { {
 	.digestsize		= SHA3_224_DIGEST_SIZE,
 	.init			= crypto_sha3_init,
@@ -306,18 +277,6 @@ static struct shash_alg algs[] = { {
 	.base.cra_driver_name	= "sha3-512-generic",
 	.base.cra_blocksize	= SHA3_512_BLOCK_SIZE,
 	.base.cra_module	= THIS_MODULE,
-#ifdef CONFIG_CRYPTO_KECCAK
-}, {
-	.digestsize		= SHA3_256_DIGEST_SIZE,
-	.init			= crypto_sha3_init,
-	.update			= crypto_sha3_update,
-	.final			= crypto_keccak_final,
-	.descsize		= sizeof(struct sha3_state),
-	.base.cra_name		= "keccak-256",
-	.base.cra_driver_name	= "keccak-256-generic",
-	.base.cra_blocksize	= SHA3_256_BLOCK_SIZE,
-	.base.cra_module	= THIS_MODULE,
-#endif
 } };
 
 static int __init sha3_generic_mod_init(void)
@@ -344,7 +303,3 @@ MODULE_ALIAS_CRYPTO("sha3-384");
 MODULE_ALIAS_CRYPTO("sha3-384-generic");
 MODULE_ALIAS_CRYPTO("sha3-512");
 MODULE_ALIAS_CRYPTO("sha3-512-generic");
-#ifdef CONFIG_CRYPTO_KECCAK
-MODULE_ALIAS_CRYPTO("keccak-256");
-MODULE_ALIAS_CRYPTO("keccak-256-generic");
-#endif

drivers/cartesi/Kconfig

@@ -14,14 +14,12 @@ config CARTESI_YIELD_DRIVER
     help
         Cartesi Machine Yield Device
 
-config CARTESI_ROLLUP_DRIVER
-    bool "Cartesi Machine Rollup Device"
+config CARTESI_MACHINE_IO_DRIVER
+    bool "Cartesi Machine IO Device"
     depends on CARTESI_MACHINE
-    depends on CRYPTO_KECCAK
     default y
     help
-        Cartesi Machine Rollup Device
-
+        Cartesi Machine IO Device
 
 config CARTESI_HALT_ON_PANIC
     bool "Halt machine on kernel panic"

drivers/cartesi/Makefile

@@ -1,2 +1 @@
-obj-$(CONFIG_CARTESI_YIELD_DRIVER) += yield.o libyield.o
-obj-$(CONFIG_CARTESI_ROLLUP_DRIVER) += rollup.o libyield.o libstream256.o
+obj-$(CONFIG_CARTESI_MACHINE_IO_DRIVER) += cmio.o

drivers/cartesi/cmio.c

@@ -0,0 +1,241 @@
+////// SPDX-License-Identifier: GPL-2.0
+/*
+ * Cartesi cmio device.
+ * Copyright (C) 2023 Cartesi Machine reference unit
+ */
+
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/ioctl.h>
+#include <linux/uaccess.h>
+#include <linux/fs.h>
+#include <linux/device.h>
+#include <linux/miscdevice.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/of.h>
+#include <asm/sbi.h>
+#include <uapi/linux/cartesi/cmio.h>
+
+#define DEVICE_NAME "cmio"
+#define MODULE_DESC "Cartesi Machine " DEVICE_NAME " device"
+
+#define SBI_YIELD 9
+
+struct cmio_device {
+	struct platform_device *pdev;
+	struct miscdevice mdev;
+	struct cmio_setup bufs;
+	atomic_t single_user_lock;
+};
+
+static struct cmio_device *to_cmio_device(struct file *file)
+{
+	struct miscdevice *dev = file->private_data;
+	return container_of(dev, struct cmio_device, mdev);
+}
+
+static long cmio_ioctl_setup(struct cmio_device *me, unsigned long arg)
+{
+	if (copy_to_user((void __user *)arg, &me->bufs, sizeof me->bufs))
+		return -EFAULT;
+
+	return 0;
+}
+
+static long cmio_ioctl_yield(struct cmio_device *me, unsigned long arg)
+{
+	__u64 req = 0,
+	      rep = 0;
+
+	if (copy_from_user(&req, (void __user *)arg, sizeof req))
+		return -EFAULT;
+
+	rep = sbi_ecall(SBI_YIELD, 0, req, 0, 0, 0, 0, 0).value;
+
+	if (copy_to_user((void __user *)arg, &rep, sizeof rep))
+		return -EFAULT;
+
+	return 0;
+}
+
+/*
+ * We enforce only one user at a time here with the open/release.
+ */
+static int cmio_open(struct inode *inode, struct file *file)
+{
+	struct cmio_device *cmio = to_cmio_device(file);
+	if (!cmio)
+		return -EBADF;
+
+	if (!atomic_inc_and_test(&cmio->single_user_lock)) {
+		atomic_dec(&cmio->single_user_lock);
+		return -EBUSY;
+	}
+	return 0;
+}
+
+static int cmio_release(struct inode *inode, struct file *file)
+{
+	struct cmio_device *cmio = to_cmio_device(file);
+	if (!cmio)
+		return -EBADF;
+
+	atomic_dec(&cmio->single_user_lock);
+	return 0;
+}
+
+static long cmio_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	struct cmio_device *cmio = to_cmio_device(file);
+	if (!cmio)
+		return -EBADF;
+
+	switch (cmd) {
+	case IOCTL_CMIO_SETUP:
+		return cmio_ioctl_setup(cmio, arg);
+	case IOCTL_CMIO_YIELD:
+		return cmio_ioctl_yield(cmio, arg);
+	}
+	return -ENOIOCTLCMD;
+}
+
+static int cmio_mmap(struct file *file, struct vm_area_struct *vma)
+{
+	__u64 vma_size;
+	struct cmio_device *cmio = to_cmio_device(file);
+	if (!cmio)
+		return -EBADF;
+
+	vma_size = vma->vm_end - vma->vm_start;
+	if (!((vma->vm_start == cmio->bufs.tx.data && vma_size == cmio->bufs.tx.length)
+	||    (vma->vm_start == cmio->bufs.rx.data && vma_size == cmio->bufs.rx.length)))
+		return -EINVAL;
+
+	return remap_pfn_range(vma,
+	                       vma->vm_start,
+	                       vma->vm_start >> PAGE_SHIFT,
+	                       vma_size,
+	                       vma->vm_page_prot);
+}
+
+static const struct file_operations cmio_fileops = {
+	.open           = cmio_open,
+	.release        = cmio_release,
+	.unlocked_ioctl = cmio_ioctl,
+	.mmap           = cmio_mmap,
+	.owner          = THIS_MODULE,
+};
+
+static int setup_buffer(struct device_node *parent, const char *name, struct cmio_buffer *buf)
+{
+	u64 xs[2];
+	int rc = -EIO;
+	struct device_node *node = NULL;
+
+	if (!(node = of_find_node_by_name(parent, name)))
+		goto leave;
+	if (of_property_read_u64_array(node, "reg", xs, 2))
+		goto leave;
+	if (!(buf->data = xs[0]))
+		goto leave;
+	if (!(buf->length = xs[1]))
+		goto leave;
+	rc = 0;
+leave:
+	of_node_put(node);
+	return rc;
+}
+
+static int check_yield_automatic_and_manual(struct device_node *node)
+{
+	return !(of_property_read_bool(node, "automatic")
+	&&       of_property_read_bool(node, "manual"));
+}
+
+static int setup_io(struct cmio_device *cmio)
+{
+	int rc = -EIO;
+	struct device_node *cmio_node = NULL,
+	                   *yield_node = NULL;
+
+	if (!(cmio_node = of_find_node_by_path("/cmio"))
+	||  setup_buffer(cmio_node, "tx_buffer", &cmio->bufs.tx)
+	||  setup_buffer(cmio_node, "rx_buffer", &cmio->bufs.rx))
+		goto leave;
+
+	if (!(yield_node = of_find_node_by_path("/yield"))
+	||    check_yield_automatic_and_manual(yield_node))
+		goto leave;
+	rc = 0;
+leave:
+	of_node_put(yield_node);
+	of_node_put(cmio_node);
+	return rc;
+}
+
+static int cmio_driver_probe(struct platform_device *pdev)
+{
+	int rc;
+	struct cmio_device *cmio;
+
+	cmio = devm_kzalloc(&pdev->dev, sizeof(*cmio), GFP_KERNEL);
+	if (!cmio)
+		return -ENOMEM;
+
+	atomic_set(&cmio->single_user_lock, -1);
+	cmio->mdev.minor = MISC_DYNAMIC_MINOR;
+	cmio->mdev.name  = DEVICE_NAME;
+	cmio->mdev.fops  = &cmio_fileops;
+	rc = misc_register(&cmio->mdev);
+	if (rc) {
+		dev_err(&pdev->dev, "failed to register miscdevice\n");
+		goto leave;
+	}
+
+	rc = setup_io(cmio);
+	if (rc) {
+		dev_err(&pdev->dev, "failed to parse device tree\n");
+		goto deregister;
+	}
+
+	platform_set_drvdata(pdev, cmio);
+	cmio->pdev = pdev;
+
+	pr_info(MODULE_DESC ": Module loaded\n");
+	return 0;
+
+deregister:
+	misc_deregister(&cmio->mdev);
+leave:
+	return rc;
+}
+
+static int cmio_driver_remove(struct platform_device *pdev)
+{
+	struct cmio_device *cmio = platform_get_drvdata(pdev);
+	misc_deregister(&cmio->mdev);
+	dev_info(&pdev->dev, "unregistered\n");
+	return 0;
+}
+
+static const struct of_device_id cmio_match[] = {
+	{.compatible = "ctsi-cmio",}, {},
+};
+MODULE_DEVICE_TABLE(of, cmio_match);
+
+static struct platform_driver cmio_driver = {
+	.driver = {
+		.name = DEVICE_NAME,
+		.of_match_table = cmio_match,
+	},
+	.probe = cmio_driver_probe,
+	.remove = cmio_driver_remove,
+};
+
+module_platform_driver(cmio_driver);
+
+MODULE_DESCRIPTION(MODULE_DESC);
+MODULE_LICENSE("GPL");