remove all older patches, all targets use 2.6.30.5

35 files changed, 0 insertions, 286794 deletions

diff --git a/target/linux/patches/2.6.28/ocf.patch b/target/linux/patches/2.6.28/ocf.patch
deleted file mode 100644
index 081e47709..000000000
--- a/target/linux/patches/2.6.28/ocf.patch
+++ /dev/null
@@ -1,23661 +0,0 @@
-diff -Nur linux-2.6.27.10.orig/crypto/Kconfig linux-2.6.27.10/crypto/Kconfig
---- linux-2.6.27.10.orig/crypto/Kconfig	2008-12-18 18:13:59.000000000 +0100
-+++ linux-2.6.27.10/crypto/Kconfig	2008-12-23 19:31:44.000000000 +0100
-@@ -669,3 +669,5 @@
- source "drivers/crypto/Kconfig"
- 
- endif	# if CRYPTO
-+
-+source "crypto/ocf/Kconfig"
-diff -Nur linux-2.6.27.10.orig/crypto/Makefile linux-2.6.27.10/crypto/Makefile
---- linux-2.6.27.10.orig/crypto/Makefile	2008-12-18 18:13:59.000000000 +0100
-+++ linux-2.6.27.10/crypto/Makefile	2008-12-23 19:31:44.000000000 +0100
-@@ -72,6 +72,8 @@
- 
- obj-$(CONFIG_CRYPTO_TEST) += tcrypt.o
- 
-+obj-$(CONFIG_OCF_OCF) += ocf/
-+
- #
- # generic algorithms and the async_tx api
- #
-diff -Nur linux-2.6.27.10.orig/crypto/ocf/Config.in linux-2.6.27.10/crypto/ocf/Config.in
---- linux-2.6.27.10.orig/crypto/ocf/Config.in	1970-01-01 01:00:00.000000000 +0100
-+++ linux-2.6.27.10/crypto/ocf/Config.in	2008-12-23 19:31:44.000000000 +0100
-@@ -0,0 +1,34 @@
-+#############################################################################
-+
-+mainmenu_option next_comment
-+comment 'OCF Configuration'
-+tristate 'OCF (Open Cryptograhic Framework)' CONFIG_OCF_OCF
-+dep_mbool '  enable fips RNG checks (fips check on RNG data before use)' \
-+				CONFIG_OCF_FIPS $CONFIG_OCF_OCF
-+dep_mbool '  enable harvesting entropy for /dev/random' \
-+				CONFIG_OCF_RANDOMHARVEST $CONFIG_OCF_OCF
-+dep_tristate '  cryptodev (user space support)' \
-+				CONFIG_OCF_CRYPTODEV $CONFIG_OCF_OCF
-+dep_tristate '  cryptosoft (software crypto engine)' \
-+				CONFIG_OCF_CRYPTOSOFT $CONFIG_OCF_OCF
-+dep_tristate '  safenet (HW crypto engine)' \
-+				CONFIG_OCF_SAFE $CONFIG_OCF_OCF
-+dep_tristate '  IXP4xx (HW crypto engine)' \
-+				CONFIG_OCF_IXP4XX $CONFIG_OCF_OCF
-+dep_mbool    '  Enable IXP4xx HW to perform SHA1 and MD5 hashing (very slow)' \
-+				CONFIG_OCF_IXP4XX_SHA1_MD5 $CONFIG_OCF_IXP4XX
-+dep_tristate '  hifn (HW crypto engine)' \
-+				CONFIG_OCF_HIFN $CONFIG_OCF_OCF
-+dep_tristate '  talitos (HW crypto engine)' \
-+				CONFIG_OCF_TALITOS $CONFIG_OCF_OCF
-+dep_tristate '  pasemi (HW crypto engine)' \
-+				CONFIG_OCF_PASEMI $CONFIG_OCF_OCF
-+dep_tristate '  ep80579 (HW crypto engine)' \
-+				CONFIG_OCF_EP80579 $CONFIG_OCF_OCF
-+dep_tristate '  ocfnull (does no crypto)' \
-+				CONFIG_OCF_OCFNULL $CONFIG_OCF_OCF
-+dep_tristate '  ocf-bench (HW crypto in-kernel benchmark)' \
-+				CONFIG_OCF_BENCH $CONFIG_OCF_OCF
-+endmenu
-+
-+#############################################################################
-diff -Nur linux-2.6.27.10.orig/crypto/ocf/criov.c linux-2.6.27.10/crypto/ocf/criov.c
---- linux-2.6.27.10.orig/crypto/ocf/criov.c	1970-01-01 01:00:00.000000000 +0100
-+++ linux-2.6.27.10/crypto/ocf/criov.c	2008-12-23 19:31:44.000000000 +0100
-@@ -0,0 +1,215 @@
-+/*      $OpenBSD: criov.c,v 1.9 2002/01/29 15:48:29 jason Exp $	*/
-+
-+/*
-+ * Linux port done by David McCullough <david_mccullough@securecomputing.com>
-+ * Copyright (C) 2006-2007 David McCullough
-+ * Copyright (C) 2004-2005 Intel Corporation.
-+ * The license and original author are listed below.
-+ *
-+ * Copyright (c) 1999 Theo de Raadt
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions
-+ * are met:
-+ *
-+ * 1. Redistributions of source code must retain the above copyright
-+ *   notice, this list of conditions and the following disclaimer.
-+ * 2. Redistributions in binary form must reproduce the above copyright
-+ *   notice, this list of conditions and the following disclaimer in the
-+ *   documentation and/or other materials provided with the distribution.
-+ * 3. The name of the author may not be used to endorse or promote products
-+ *   derived from this software without specific prior written permission.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+ *
-+__FBSDID("$FreeBSD: src/sys/opencrypto/criov.c,v 1.5 2006/06/04 22:15:13 pjd Exp $");
-+ */
-+
-+#ifndef AUTOCONF_INCLUDED
-+#include <linux/config.h>
-+#endif
-+#include <linux/module.h>
-+#include <linux/init.h>
-+#include <linux/slab.h>
-+#include <linux/uio.h>
-+#include <linux/skbuff.h>
-+#include <linux/kernel.h>
-+#include <linux/mm.h>
-+#include <asm/io.h>
-+
-+#include <uio.h>
-+#include <cryptodev.h>
-+
-+/*
-+ * This macro is only for avoiding code duplication, as we need to skip
-+ * given number of bytes in the same way in three functions below.
-+ */
-+#define	CUIO_SKIP()	do {						\
-+	KASSERT(off >= 0, ("%s: off %d < 0", __func__, off));		\
-+	KASSERT(len >= 0, ("%s: len %d < 0", __func__, len));		\
-+	while (off > 0) {						\
-+		KASSERT(iol >= 0, ("%s: empty in skip", __func__));	\
-+		if (off < iov->iov_len)					\
-+			break;						\
-+		off -= iov->iov_len;					\
-+		iol--;							\
-+		iov++;							\
-+	}								\
-+} while (0)
-+
-+void
-+cuio_copydata(struct uio* uio, int off, int len, caddr_t cp)
-+{
-+	struct iovec *iov = uio->uio_iov;
-+	int iol = uio->uio_iovcnt;
-+	unsigned count;
-+
-+	CUIO_SKIP();
-+	while (len > 0) {
-+		KASSERT(iol >= 0, ("%s: empty", __func__));
-+		count = min((int)(iov->iov_len - off), len);
-+		memcpy(cp, ((caddr_t)iov->iov_base) + off, count);
-+		len -= count;
-+		cp += count;
-+		off = 0;
-+		iol--;
-+		iov++;
-+	}
-+}
-+
-+void
-+cuio_copyback(struct uio* uio, int off, int len, caddr_t cp)
-+{
-+	struct iovec *iov = uio->uio_iov;
-+	int iol = uio->uio_iovcnt;
-+	unsigned count;
-+
-+	CUIO_SKIP();
-+	while (len > 0) {
-+		KASSERT(iol >= 0, ("%s: empty", __func__));
-+		count = min((int)(iov->iov_len - off), len);
-+		memcpy(((caddr_t)iov->iov_base) + off, cp, count);
-+		len -= count;
-+		cp += count;
-+		off = 0;
-+		iol--;
-+		iov++;
-+	}
-+}
-+
-+/*
-+ * Return a pointer to iov/offset of location in iovec list.
-+ */
-+struct iovec *
-+cuio_getptr(struct uio *uio, int loc, int *off)
-+{
-+	struct iovec *iov = uio->uio_iov;
-+	int iol = uio->uio_iovcnt;
-+
-+	while (loc >= 0) {
-+		/* Normal end of search */
-+		if (loc < iov->iov_len) {
-+	    		*off = loc;
-+	    		return (iov);
-+		}
-+
-+		loc -= iov->iov_len;
-+		if (iol == 0) {
-+			if (loc == 0) {
-+				/* Point at the end of valid data */
-+				*off = iov->iov_len;
-+				return (iov);
-+			} else
-+				return (NULL);
-+		} else {
-+			iov++, iol--;
-+		}
-+    	}
-+
-+	return (NULL);
-+}
-+
-+EXPORT_SYMBOL(cuio_copyback);
-+EXPORT_SYMBOL(cuio_copydata);
-+EXPORT_SYMBOL(cuio_getptr);
-+
-+
-+static void
-+skb_copy_bits_back(struct sk_buff *skb, int offset, caddr_t cp, int len)
-+{
-+	int i;
-+	if (offset < skb_headlen(skb)) {
-+		memcpy(skb->data + offset, cp, min_t(int, skb_headlen(skb), len));
-+		len -= skb_headlen(skb);
-+		cp += skb_headlen(skb);
-+	}
-+	offset -= skb_headlen(skb);
-+	for (i = 0; len > 0 && i < skb_shinfo(skb)->nr_frags; i++) {
-+		if (offset < skb_shinfo(skb)->frags[i].size) {
-+			memcpy(page_address(skb_shinfo(skb)->frags[i].page) +
-+					skb_shinfo(skb)->frags[i].page_offset,
-+					cp, min_t(int, skb_shinfo(skb)->frags[i].size, len));
-+			len -= skb_shinfo(skb)->frags[i].size;
-+			cp += skb_shinfo(skb)->frags[i].size;
-+		}
-+		offset -= skb_shinfo(skb)->frags[i].size;
-+	}
-+}
-+
-+void
-+crypto_copyback(int flags, caddr_t buf, int off, int size, caddr_t in)
-+{
-+
-+	if ((flags & CRYPTO_F_SKBUF) != 0)
-+		skb_copy_bits_back((struct sk_buff *)buf, off, in, size);
-+	else if ((flags & CRYPTO_F_IOV) != 0)
-+		cuio_copyback((struct uio *)buf, off, size, in);
-+	else
-+		bcopy(in, buf + off, size);
-+}
-+
-+void
-+crypto_copydata(int flags, caddr_t buf, int off, int size, caddr_t out)
-+{
-+
-+	if ((flags & CRYPTO_F_SKBUF) != 0)
-+		skb_copy_bits((struct sk_buff *)buf, off, out, size);
-+	else if ((flags & CRYPTO_F_IOV) != 0)
-+		cuio_copydata((struct uio *)buf, off, size, out);
-+	else
-+		bcopy(buf + off, out, size);
-+}
-+
-+int
-+crypto_apply(int flags, caddr_t buf, int off, int len,
-+    int (*f)(void *, void *, u_int), void *arg)
-+{
-+#if 0
-+	int error;
-+
-+	if ((flags & CRYPTO_F_SKBUF) != 0)
-+		error = XXXXXX((struct mbuf *)buf, off, len, f, arg);
-+	else if ((flags & CRYPTO_F_IOV) != 0)
-+		error = cuio_apply((struct uio *)buf, off, len, f, arg);
-+	else
-+		error = (*f)(arg, buf + off, len);
-+	return (error);
-+#else
-+	KASSERT(0, ("crypto_apply not implemented!\n"));
-+#endif
-+	return 0;
-+}
-+
-+EXPORT_SYMBOL(crypto_copyback);
-+EXPORT_SYMBOL(crypto_copydata);
-+EXPORT_SYMBOL(crypto_apply);
-+
-diff -Nur linux-2.6.27.10.orig/crypto/ocf/crypto.c linux-2.6.27.10/crypto/ocf/crypto.c
---- linux-2.6.27.10.orig/crypto/ocf/crypto.c	1970-01-01 01:00:00.000000000 +0100
-+++ linux-2.6.27.10/crypto/ocf/crypto.c	2008-12-23 19:31:44.000000000 +0100
-@@ -0,0 +1,1741 @@
-+/*-
-+ * Linux port done by David McCullough <david_mccullough@securecomputing.com>
-+ * Copyright (C) 2006-2007 David McCullough
-+ * Copyright (C) 2004-2005 Intel Corporation.
-+ * The license and original author are listed below.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * Copyright (c) 2002-2006 Sam Leffler.  All rights reserved.
-+ *
-+ * modification, are permitted provided that the following conditions
-+ * are met:
-+ * 1. Redistributions of source code must retain the above copyright
-+ *    notice, this list of conditions and the following disclaimer.
-+ * 2. Redistributions in binary form must reproduce the above copyright
-+ *    notice, this list of conditions and the following disclaimer in the
-+ *    documentation and/or other materials provided with the distribution.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+#if 0
-+#include <sys/cdefs.h>
-+__FBSDID("$FreeBSD: src/sys/opencrypto/crypto.c,v 1.27 2007/03/21 03:42:51 sam Exp $");
-+#endif
-+
-+/*
-+ * Cryptographic Subsystem.
-+ *
-+ * This code is derived from the Openbsd Cryptographic Framework (OCF)
-+ * that has the copyright shown below.  Very little of the original
-+ * code remains.
-+ */
-+/*-
-+ * The author of this code is Angelos D. Keromytis (angelos@cis.upenn.edu)
-+ *
-+ * This code was written by Angelos D. Keromytis in Athens, Greece, in
-+ * February 2000. Network Security Technologies Inc. (NSTI) kindly
-+ * supported the development of this code.
-+ *
-+ * Copyright (c) 2000, 2001 Angelos D. Keromytis
-+ *
-+ * Permission to use, copy, and modify this software with or without fee
-+ * is hereby granted, provided that this entire notice is included in
-+ * all source code copies of any software which is or includes a copy or
-+ * modification of this software.
-+ *
-+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR
-+ * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY
-+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE
-+ * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
-+ * PURPOSE.
-+ *
-+__FBSDID("$FreeBSD: src/sys/opencrypto/crypto.c,v 1.16 2005/01/07 02:29:16 imp Exp $");
-+ */
-+
-+
-+#ifndef AUTOCONF_INCLUDED
-+#include <linux/config.h>
-+#endif
-+#include <linux/module.h>
-+#include <linux/init.h>
-+#include <linux/list.h>
-+#include <linux/slab.h>
-+#include <linux/wait.h>
-+#include <linux/sched.h>
-+#include <linux/spinlock.h>
-+#include <linux/version.h>
-+#include <cryptodev.h>
-+
-+/*
-+ * keep track of whether or not we have been initialised, a big
-+ * issue if we are linked into the kernel and a driver gets started before
-+ * us
-+ */
-+static int crypto_initted = 0;
-+
-+/*
-+ * Crypto drivers register themselves by allocating a slot in the
-+ * crypto_drivers table with crypto_get_driverid() and then registering
-+ * each algorithm they support with crypto_register() and crypto_kregister().
-+ */
-+
-+/*
-+ * lock on driver table
-+ * we track its state as spin_is_locked does not do anything on non-SMP boxes
-+ */
-+static spinlock_t	crypto_drivers_lock;
-+static int			crypto_drivers_locked;		/* for non-SMP boxes */
-+
-+#define	CRYPTO_DRIVER_LOCK() \
-+			({ \
-+				spin_lock_irqsave(&crypto_drivers_lock, d_flags); \
-+			 	crypto_drivers_locked = 1; \
-+				dprintk("%s,%d: DRIVER_LOCK()\n", __FILE__, __LINE__); \
-+			 })
-+#define	CRYPTO_DRIVER_UNLOCK() \
-+			({ \
-+			 	dprintk("%s,%d: DRIVER_UNLOCK()\n", __FILE__, __LINE__); \
-+			 	crypto_drivers_locked = 0; \
-+				spin_unlock_irqrestore(&crypto_drivers_lock, d_flags); \
-+			 })
-+#define	CRYPTO_DRIVER_ASSERT() \
-+			({ \
-+			 	if (!crypto_drivers_locked) { \
-+					dprintk("%s,%d: DRIVER_ASSERT!\n", __FILE__, __LINE__); \
-+			 	} \
-+			 })
-+
-+/*
-+ * Crypto device/driver capabilities structure.
-+ *
-+ * Synchronization:
-+ * (d) - protected by CRYPTO_DRIVER_LOCK()
-+ * (q) - protected by CRYPTO_Q_LOCK()
-+ * Not tagged fields are read-only.
-+ */
-+struct cryptocap {
-+	device_t	cc_dev;			/* (d) device/driver */
-+	u_int32_t	cc_sessions;		/* (d) # of sessions */
-+	u_int32_t	cc_koperations;		/* (d) # os asym operations */
-+	/*
-+	 * Largest possible operator length (in bits) for each type of
-+	 * encryption algorithm. XXX not used
-+	 */
-+	u_int16_t	cc_max_op_len[CRYPTO_ALGORITHM_MAX + 1];
-+	u_int8_t	cc_alg[CRYPTO_ALGORITHM_MAX + 1];
-+	u_int8_t	cc_kalg[CRK_ALGORITHM_MAX + 1];
-+
-+	int		cc_flags;		/* (d) flags */
-+#define CRYPTOCAP_F_CLEANUP	0x80000000	/* needs resource cleanup */
-+	int		cc_qblocked;		/* (q) symmetric q blocked */
-+	int		cc_kqblocked;		/* (q) asymmetric q blocked */
-+};
-+static struct cryptocap *crypto_drivers = NULL;
-+static int crypto_drivers_num = 0;
-+
-+/*
-+ * There are two queues for crypto requests; one for symmetric (e.g.
-+ * cipher) operations and one for asymmetric (e.g. MOD)operations.
-+ * A single mutex is used to lock access to both queues.  We could
-+ * have one per-queue but having one simplifies handling of block/unblock
-+ * operations.
-+ */
-+static	int crp_sleep = 0;
-+static LIST_HEAD(crp_q);		/* request queues */
-+static LIST_HEAD(crp_kq);
-+
-+static spinlock_t crypto_q_lock;
-+
-+int crypto_all_qblocked = 0;  /* protect with Q_LOCK */
-+module_param(crypto_all_qblocked, int, 0444);
-+MODULE_PARM_DESC(crypto_all_qblocked, "Are all crypto queues blocked");
-+
-+int crypto_all_kqblocked = 0; /* protect with Q_LOCK */
-+module_param(crypto_all_kqblocked, int, 0444);
-+MODULE_PARM_DESC(crypto_all_kqblocked, "Are all asym crypto queues blocked");
-+
-+#define	CRYPTO_Q_LOCK() \
-+			({ \
-+				spin_lock_irqsave(&crypto_q_lock, q_flags); \
-+			 	dprintk("%s,%d: Q_LOCK()\n", __FILE__, __LINE__); \
-+			 })
-+#define	CRYPTO_Q_UNLOCK() \
-+			({ \
-+			 	dprintk("%s,%d: Q_UNLOCK()\n", __FILE__, __LINE__); \
-+				spin_unlock_irqrestore(&crypto_q_lock, q_flags); \
-+			 })
-+
-+/*
-+ * There are two queues for processing completed crypto requests; one
-+ * for the symmetric and one for the asymmetric ops.  We only need one
-+ * but have two to avoid type futzing (cryptop vs. cryptkop).  A single
-+ * mutex is used to lock access to both queues.  Note that this lock
-+ * must be separate from the lock on request queues to insure driver
-+ * callbacks don't generate lock order reversals.
-+ */
-+static LIST_HEAD(crp_ret_q);		/* callback queues */
-+static LIST_HEAD(crp_ret_kq);
-+
-+static spinlock_t crypto_ret_q_lock;
-+#define	CRYPTO_RETQ_LOCK() \
-+			({ \
-+				spin_lock_irqsave(&crypto_ret_q_lock, r_flags); \
-+				dprintk("%s,%d: RETQ_LOCK\n", __FILE__, __LINE__); \
-+			 })
-+#define	CRYPTO_RETQ_UNLOCK() \
-+			({ \
-+			 	dprintk("%s,%d: RETQ_UNLOCK\n", __FILE__, __LINE__); \
-+				spin_unlock_irqrestore(&crypto_ret_q_lock, r_flags); \
-+			 })
-+#define	CRYPTO_RETQ_EMPTY()	(list_empty(&crp_ret_q) && list_empty(&crp_ret_kq))
-+
-+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
-+static kmem_cache_t *cryptop_zone;
-+static kmem_cache_t *cryptodesc_zone;
-+#else
-+static struct kmem_cache *cryptop_zone;
-+static struct kmem_cache *cryptodesc_zone;
-+#endif
-+
-+#define debug crypto_debug
-+int crypto_debug = 0;
-+module_param(crypto_debug, int, 0644);
-+MODULE_PARM_DESC(crypto_debug, "Enable debug");
-+EXPORT_SYMBOL(crypto_debug);
-+
-+/*
-+ * Maximum number of outstanding crypto requests before we start
-+ * failing requests.  We need this to prevent DOS when too many
-+ * requests are arriving for us to keep up.  Otherwise we will
-+ * run the system out of memory.  Since crypto is slow,  we are
-+ * usually the bottleneck that needs to say, enough is enough.
-+ *
-+ * We cannot print errors when this condition occurs,  we are already too
-+ * slow,  printing anything will just kill us
-+ */
-+
-+static int crypto_q_cnt = 0;
-+module_param(crypto_q_cnt, int, 0444);
-+MODULE_PARM_DESC(crypto_q_cnt,
-+		"Current number of outstanding crypto requests");
-+
-+static int crypto_q_max = 1000;
-+module_param(crypto_q_max, int, 0644);
-+MODULE_PARM_DESC(crypto_q_max,
-+		"Maximum number of outstanding crypto requests");
-+
-+#define bootverbose crypto_verbose
-+static int crypto_verbose = 0;
-+module_param(crypto_verbose, int, 0644);
-+MODULE_PARM_DESC(crypto_verbose,
-+		"Enable verbose crypto startup");
-+
-+int	crypto_usercrypto = 1;	/* userland may do crypto reqs */
-+module_param(crypto_usercrypto, int, 0644);
-+MODULE_PARM_DESC(crypto_usercrypto,
-+	   "Enable/disable user-mode access to crypto support");
-+
-+int	crypto_userasymcrypto = 1;	/* userland may do asym crypto reqs */
-+module_param(crypto_userasymcrypto, int, 0644);
-+MODULE_PARM_DESC(crypto_userasymcrypto,
-+	   "Enable/disable user-mode access to asymmetric crypto support");
-+
-+int	crypto_devallowsoft = 0;	/* only use hardware crypto */
-+module_param(crypto_devallowsoft, int, 0644);
-+MODULE_PARM_DESC(crypto_devallowsoft,
-+	   "Enable/disable use of software crypto support");
-+
-+static pid_t	cryptoproc = (pid_t) -1;
-+static struct	completion cryptoproc_exited;
-+static DECLARE_WAIT_QUEUE_HEAD(cryptoproc_wait);
-+static pid_t	cryptoretproc = (pid_t) -1;
-+static struct	completion cryptoretproc_exited;
-+static DECLARE_WAIT_QUEUE_HEAD(cryptoretproc_wait);
-+
-+static	int crypto_proc(void *arg);
-+static	int crypto_ret_proc(void *arg);
-+static	int crypto_invoke(struct cryptocap *cap, struct cryptop *crp, int hint);
-+static	int crypto_kinvoke(struct cryptkop *krp, int flags);
-+static	void crypto_exit(void);
-+static  int crypto_init(void);
-+
-+static	struct cryptostats cryptostats;
-+
-+static struct cryptocap *
-+crypto_checkdriver(u_int32_t hid)
-+{
-+	if (crypto_drivers == NULL)
-+		return NULL;
-+	return (hid >= crypto_drivers_num ? NULL : &crypto_drivers[hid]);
-+}
-+
-+/*
-+ * Compare a driver's list of supported algorithms against another
-+ * list; return non-zero if all algorithms are supported.
-+ */
-+static int
-+driver_suitable(const struct cryptocap *cap, const struct cryptoini *cri)
-+{
-+	const struct cryptoini *cr;
-+
-+	/* See if all the algorithms are supported. */
-+	for (cr = cri; cr; cr = cr->cri_next)
-+		if (cap->cc_alg[cr->cri_alg] == 0)
-+			return 0;
-+	return 1;
-+}
-+
-+/*
-+ * Select a driver for a new session that supports the specified
-+ * algorithms and, optionally, is constrained according to the flags.
-+ * The algorithm we use here is pretty stupid; just use the
-+ * first driver that supports all the algorithms we need. If there
-+ * are multiple drivers we choose the driver with the fewest active
-+ * sessions.  We prefer hardware-backed drivers to software ones.
-+ *
-+ * XXX We need more smarts here (in real life too, but that's
-+ * XXX another story altogether).
-+ */
-+static struct cryptocap *
-+crypto_select_driver(const struct cryptoini *cri, int flags)
-+{
-+	struct cryptocap *cap, *best;
-+	int match, hid;
-+
-+	CRYPTO_DRIVER_ASSERT();
-+
-+	/*
-+	 * Look first for hardware crypto devices if permitted.
-+	 */
-+	if (flags & CRYPTOCAP_F_HARDWARE)
-+		match = CRYPTOCAP_F_HARDWARE;
-+	else
-+		match = CRYPTOCAP_F_SOFTWARE;
-+	best = NULL;
-+again:
-+	for (hid = 0; hid < crypto_drivers_num; hid++) {
-+		cap = &crypto_drivers[hid];
-+		/*
-+		 * If it's not initialized, is in the process of
-+		 * going away, or is not appropriate (hardware
-+		 * or software based on match), then skip.
-+		 */
-+		if (cap->cc_dev == NULL ||
-+		    (cap->cc_flags & CRYPTOCAP_F_CLEANUP) ||
-+		    (cap->cc_flags & match) == 0)
-+			continue;
-+
-+		/* verify all the algorithms are supported. */
-+		if (driver_suitable(cap, cri)) {
-+			if (best == NULL ||
-+			    cap->cc_sessions < best->cc_sessions)
-+				best = cap;
-+		}
-+	}
-+	if (best != NULL)
-+		return best;
-+	if (match == CRYPTOCAP_F_HARDWARE && (flags & CRYPTOCAP_F_SOFTWARE)) {
-+		/* sort of an Algol 68-style for loop */
-+		match = CRYPTOCAP_F_SOFTWARE;
-+		goto again;
-+	}
-+	return best;
-+}
-+
-+/*
-+ * Create a new session.  The crid argument specifies a crypto
-+ * driver to use or constraints on a driver to select (hardware
-+ * only, software only, either).  Whatever driver is selected
-+ * must be capable of the requested crypto algorithms.
-+ */
-+int
-+crypto_newsession(u_int64_t *sid, struct cryptoini *cri, int crid)
-+{
-+	struct cryptocap *cap;
-+	u_int32_t hid, lid;
-+	int err;
-+	unsigned long d_flags;
-+
-+	CRYPTO_DRIVER_LOCK();
-+	if ((crid & (CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SOFTWARE)) == 0) {
-+		/*
-+		 * Use specified driver; verify it is capable.
-+		 */
-+		cap = crypto_checkdriver(crid);
-+		if (cap != NULL && !driver_suitable(cap, cri))
-+			cap = NULL;
-+	} else {
-+		/*
-+		 * No requested driver; select based on crid flags.
-+		 */
-+		cap = crypto_select_driver(cri, crid);
-+		/*
-+		 * if NULL then can't do everything in one session.
-+		 * XXX Fix this. We need to inject a "virtual" session
-+		 * XXX layer right about here.
-+		 */
-+	}
-+	if (cap != NULL) {
-+		/* Call the driver initialization routine. */
-+		hid = cap - crypto_drivers;
-+		lid = hid;		/* Pass the driver ID. */
-+		cap->cc_sessions++;
-+		CRYPTO_DRIVER_UNLOCK();
-+		err = CRYPTODEV_NEWSESSION(cap->cc_dev, &lid, cri);
-+		CRYPTO_DRIVER_LOCK();
-+		if (err == 0) {
-+			(*sid) = (cap->cc_flags & 0xff000000)
-+			       | (hid & 0x00ffffff);
-+			(*sid) <<= 32;
-+			(*sid) |= (lid & 0xffffffff);
-+		} else
-+			cap->cc_sessions--;
-+	} else
-+		err = EINVAL;
-+	CRYPTO_DRIVER_UNLOCK();
-+	return err;
-+}
-+
-+static void
-+crypto_remove(struct cryptocap *cap)
-+{
-+	CRYPTO_DRIVER_ASSERT();
-+	if (cap->cc_sessions == 0 && cap->cc_koperations == 0)
-+		bzero(cap, sizeof(*cap));
-+}
-+
-+/*
-+ * Delete an existing session (or a reserved session on an unregistered
-+ * driver).
-+ */
-+int
-+crypto_freesession(u_int64_t sid)
-+{
-+	struct cryptocap *cap;
-+	u_int32_t hid;
-+	int err = 0;
-+	unsigned long d_flags;
-+
-+	dprintk("%s()\n", __FUNCTION__);
-+	CRYPTO_DRIVER_LOCK();
-+
-+	if (crypto_drivers == NULL) {
-+		err = EINVAL;
-+		goto done;
-+	}
-+
-+	/* Determine two IDs. */
-+	hid = CRYPTO_SESID2HID(sid);
-+
-+	if (hid >= crypto_drivers_num) {
-+		dprintk("%s - INVALID DRIVER NUM %d\n", __FUNCTION__, hid);
-+		err = ENOENT;
-+		goto done;
-+	}
-+	cap = &crypto_drivers[hid];
-+
-+	if (cap->cc_dev) {
-+		CRYPTO_DRIVER_UNLOCK();
-+		/* Call the driver cleanup routine, if available, unlocked. */
-+		err = CRYPTODEV_FREESESSION(cap->cc_dev, sid);
-+		CRYPTO_DRIVER_LOCK();
-+	}
-+
-+	if (cap->cc_sessions)
-+		cap->cc_sessions--;
-+
-+	if (cap->cc_flags & CRYPTOCAP_F_CLEANUP)
-+		crypto_remove(cap);
-+
-+done:
-+	CRYPTO_DRIVER_UNLOCK();
-+	return err;
-+}
-+
-+/*
-+ * Return an unused driver id.  Used by drivers prior to registering
-+ * support for the algorithms they handle.
-+ */
-+int32_t
-+crypto_get_driverid(device_t dev, int flags)
-+{
-+	struct cryptocap *newdrv;
-+	int i;
-+	unsigned long d_flags;
-+
-+	if ((flags & (CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SOFTWARE)) == 0) {
-+		printf("%s: no flags specified when registering driver\n",
-+		    device_get_nameunit(dev));
-+		return -1;
-+	}
-+
-+	CRYPTO_DRIVER_LOCK();
-+
-+	for (i = 0; i < crypto_drivers_num; i++) {
-+		if (crypto_drivers[i].cc_dev == NULL &&
-+		    (crypto_drivers[i].cc_flags & CRYPTOCAP_F_CLEANUP) == 0) {
-+			break;
-+		}
-+	}
-+
-+	/* Out of entries, allocate som