rename libdde_linux26 into libdde-linux26 to make dpkg-source happy

14 files changed, 0 insertions, 1510 deletions

diff --git a/libdde_linux26/contrib/include/crypto/aead.h b/libdde_linux26/contrib/include/crypto/aead.h
deleted file mode 100644
index 0edf949f..00000000
--- a/libdde_linux26/contrib/include/crypto/aead.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * AEAD: Authenticated Encryption with Associated Data
- * 
- * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
- *
- * 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.
- *
- */
-
-#ifndef _CRYPTO_AEAD_H
-#define _CRYPTO_AEAD_H
-
-#include <linux/crypto.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-
-/**
- *	struct aead_givcrypt_request - AEAD request with IV generation
- *	@seq: Sequence number for IV generation
- *	@giv: Space for generated IV
- *	@areq: The AEAD request itself
- */
-struct aead_givcrypt_request {
-	u64 seq;
-	u8 *giv;
-
-	struct aead_request areq;
-};
-
-static inline struct crypto_aead *aead_givcrypt_reqtfm(
-	struct aead_givcrypt_request *req)
-{
-	return crypto_aead_reqtfm(&req->areq);
-}
-
-static inline int crypto_aead_givencrypt(struct aead_givcrypt_request *req)
-{
-	struct aead_tfm *crt = crypto_aead_crt(aead_givcrypt_reqtfm(req));
-	return crt->givencrypt(req);
-};
-
-static inline int crypto_aead_givdecrypt(struct aead_givcrypt_request *req)
-{
-	struct aead_tfm *crt = crypto_aead_crt(aead_givcrypt_reqtfm(req));
-	return crt->givdecrypt(req);
-};
-
-static inline void aead_givcrypt_set_tfm(struct aead_givcrypt_request *req,
-					 struct crypto_aead *tfm)
-{
-	req->areq.base.tfm = crypto_aead_tfm(tfm);
-}
-
-static inline struct aead_givcrypt_request *aead_givcrypt_alloc(
-	struct crypto_aead *tfm, gfp_t gfp)
-{
-	struct aead_givcrypt_request *req;
-
-	req = kmalloc(sizeof(struct aead_givcrypt_request) +
-		      crypto_aead_reqsize(tfm), gfp);
-
-	if (likely(req))
-		aead_givcrypt_set_tfm(req, tfm);
-
-	return req;
-}
-
-static inline void aead_givcrypt_free(struct aead_givcrypt_request *req)
-{
-	kfree(req);
-}
-
-static inline void aead_givcrypt_set_callback(
-	struct aead_givcrypt_request *req, u32 flags,
-	crypto_completion_t complete, void *data)
-{
-	aead_request_set_callback(&req->areq, flags, complete, data);
-}
-
-static inline void aead_givcrypt_set_crypt(struct aead_givcrypt_request *req,
-					   struct scatterlist *src,
-					   struct scatterlist *dst,
-					   unsigned int nbytes, void *iv)
-{
-	aead_request_set_crypt(&req->areq, src, dst, nbytes, iv);
-}
-
-static inline void aead_givcrypt_set_assoc(struct aead_givcrypt_request *req,
-					   struct scatterlist *assoc,
-					   unsigned int assoclen)
-{
-	aead_request_set_assoc(&req->areq, assoc, assoclen);
-}
-
-static inline void aead_givcrypt_set_giv(struct aead_givcrypt_request *req,
-					 u8 *giv, u64 seq)
-{
-	req->giv = giv;
-	req->seq = seq;
-}
-
-#endif	/* _CRYPTO_AEAD_H */
diff --git a/libdde_linux26/contrib/include/crypto/aes.h b/libdde_linux26/contrib/include/crypto/aes.h
deleted file mode 100644
index 656a4c66..00000000
--- a/libdde_linux26/contrib/include/crypto/aes.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Common values for AES algorithms
- */
-
-#ifndef _CRYPTO_AES_H
-#define _CRYPTO_AES_H
-
-#include <linux/types.h>
-#include <linux/crypto.h>
-
-#define AES_MIN_KEY_SIZE	16
-#define AES_MAX_KEY_SIZE	32
-#define AES_KEYSIZE_128		16
-#define AES_KEYSIZE_192		24
-#define AES_KEYSIZE_256		32
-#define AES_BLOCK_SIZE		16
-#define AES_MAX_KEYLENGTH	(15 * 16)
-#define AES_MAX_KEYLENGTH_U32	(AES_MAX_KEYLENGTH / sizeof(u32))
-
-struct crypto_aes_ctx {
-	u32 key_length;
-	u32 key_enc[AES_MAX_KEYLENGTH_U32];
-	u32 key_dec[AES_MAX_KEYLENGTH_U32];
-};
-
-extern const u32 crypto_ft_tab[4][256];
-extern const u32 crypto_fl_tab[4][256];
-extern const u32 crypto_it_tab[4][256];
-extern const u32 crypto_il_tab[4][256];
-
-int crypto_aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
-		unsigned int key_len);
-int crypto_aes_expand_key(struct crypto_aes_ctx *ctx, const u8 *in_key,
-		unsigned int key_len);
-#endif
diff --git a/libdde_linux26/contrib/include/crypto/algapi.h b/libdde_linux26/contrib/include/crypto/algapi.h
deleted file mode 100644
index 01054543..00000000
--- a/libdde_linux26/contrib/include/crypto/algapi.h
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
- * Cryptographic API for algorithms (i.e., low-level API).
- *
- * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
- *
- * 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.
- *
- */
-#ifndef _CRYPTO_ALGAPI_H
-#define _CRYPTO_ALGAPI_H
-
-#include <linux/crypto.h>
-#include <linux/list.h>
-#include <linux/kernel.h>
-
-struct module;
-struct rtattr;
-struct seq_file;
-
-struct crypto_type {
-	unsigned int (*ctxsize)(struct crypto_alg *alg, u32 type, u32 mask);
-	unsigned int (*extsize)(struct crypto_alg *alg,
-				const struct crypto_type *frontend);
-	int (*init)(struct crypto_tfm *tfm, u32 type, u32 mask);
-	int (*init_tfm)(struct crypto_tfm *tfm,
-		        const struct crypto_type *frontend);
-	void (*show)(struct seq_file *m, struct crypto_alg *alg);
-	struct crypto_alg *(*lookup)(const char *name, u32 type, u32 mask);
-
-	unsigned int type;
-	unsigned int maskclear;
-	unsigned int maskset;
-	unsigned int tfmsize;
-};
-
-struct crypto_instance {
-	struct crypto_alg alg;
-
-	struct crypto_template *tmpl;
-	struct hlist_node list;
-
-	void *__ctx[] CRYPTO_MINALIGN_ATTR;
-};
-
-struct crypto_template {
-	struct list_head list;
-	struct hlist_head instances;
-	struct module *module;
-
-	struct crypto_instance *(*alloc)(struct rtattr **tb);
-	void (*free)(struct crypto_instance *inst);
-
-	char name[CRYPTO_MAX_ALG_NAME];
-};
-
-struct crypto_spawn {
-	struct list_head list;
-	struct crypto_alg *alg;
-	struct crypto_instance *inst;
-	u32 mask;
-};
-
-struct crypto_queue {
-	struct list_head list;
-	struct list_head *backlog;
-
-	unsigned int qlen;
-	unsigned int max_qlen;
-};
-
-struct scatter_walk {
-	struct scatterlist *sg;
-	unsigned int offset;
-};
-
-struct blkcipher_walk {
-	union {
-		struct {
-			struct page *page;
-			unsigned long offset;
-		} phys;
-
-		struct {
-			u8 *page;
-			u8 *addr;
-		} virt;
-	} src, dst;
-
-	struct scatter_walk in;
-	unsigned int nbytes;
-
-	struct scatter_walk out;
-	unsigned int total;
-
-	void *page;
-	u8 *buffer;
-	u8 *iv;
-
-	int flags;
-	unsigned int blocksize;
-};
-
-extern const struct crypto_type crypto_ablkcipher_type;
-extern const struct crypto_type crypto_aead_type;
-extern const struct crypto_type crypto_blkcipher_type;
-extern const struct crypto_type crypto_hash_type;
-
-void crypto_mod_put(struct crypto_alg *alg);
-
-int crypto_register_template(struct crypto_template *tmpl);
-void crypto_unregister_template(struct crypto_template *tmpl);
-struct crypto_template *crypto_lookup_template(const char *name);
-
-int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg,
-		      struct crypto_instance *inst, u32 mask);
-void crypto_drop_spawn(struct crypto_spawn *spawn);
-struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type,
-				    u32 mask);
-
-static inline void crypto_set_spawn(struct crypto_spawn *spawn,
-				    struct crypto_instance *inst)
-{
-	spawn->inst = inst;
-}
-
-struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb);
-int crypto_check_attr_type(struct rtattr **tb, u32 type);
-const char *crypto_attr_alg_name(struct rtattr *rta);
-struct crypto_alg *crypto_attr_alg(struct rtattr *rta, u32 type, u32 mask);
-int crypto_attr_u32(struct rtattr *rta, u32 *num);
-struct crypto_instance *crypto_alloc_instance(const char *name,
-					      struct crypto_alg *alg);
-
-void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen);
-int crypto_enqueue_request(struct crypto_queue *queue,
-			   struct crypto_async_request *request);
-struct crypto_async_request *crypto_dequeue_request(struct crypto_queue *queue);
-int crypto_tfm_in_queue(struct crypto_queue *queue, struct crypto_tfm *tfm);
-
-/* These functions require the input/output to be aligned as u32. */
-void crypto_inc(u8 *a, unsigned int size);
-void crypto_xor(u8 *dst, const u8 *src, unsigned int size);
-
-int blkcipher_walk_done(struct blkcipher_desc *desc,
-			struct blkcipher_walk *walk, int err);
-int blkcipher_walk_virt(struct blkcipher_desc *desc,
-			struct blkcipher_walk *walk);
-int blkcipher_walk_phys(struct blkcipher_desc *desc,
-			struct blkcipher_walk *walk);
-int blkcipher_walk_virt_block(struct blkcipher_desc *desc,
-			      struct blkcipher_walk *walk,
-			      unsigned int blocksize);
-
-static inline void *crypto_tfm_ctx_aligned(struct crypto_tfm *tfm)
-{
-	unsigned long addr = (unsigned long)crypto_tfm_ctx(tfm);
-	unsigned long align = crypto_tfm_alg_alignmask(tfm);
-
-	if (align <= crypto_tfm_ctx_alignment())
-		align = 1;
-	return (void *)ALIGN(addr, align);
-}
-
-static inline struct crypto_instance *crypto_tfm_alg_instance(
-	struct crypto_tfm *tfm)
-{
-	return container_of(tfm->__crt_alg, struct crypto_instance, alg);
-}
-
-static inline void *crypto_instance_ctx(struct crypto_instance *inst)
-{
-	return inst->__ctx;
-}
-
-static inline struct ablkcipher_alg *crypto_ablkcipher_alg(
-	struct crypto_ablkcipher *tfm)
-{
-	return &crypto_ablkcipher_tfm(tfm)->__crt_alg->cra_ablkcipher;
-}
-
-static inline void *crypto_ablkcipher_ctx(struct crypto_ablkcipher *tfm)
-{
-	return crypto_tfm_ctx(&tfm->base);
-}
-
-static inline void *crypto_ablkcipher_ctx_aligned(struct crypto_ablkcipher *tfm)
-{
-	return crypto_tfm_ctx_aligned(&tfm->base);
-}
-
-static inline struct aead_alg *crypto_aead_alg(struct crypto_aead *tfm)
-{
-	return &crypto_aead_tfm(tfm)->__crt_alg->cra_aead;
-}
-
-static inline void *crypto_aead_ctx(struct crypto_aead *tfm)
-{
-	return crypto_tfm_ctx(&tfm->base);
-}
-
-static inline struct crypto_instance *crypto_aead_alg_instance(
-	struct crypto_aead *aead)
-{
-	return crypto_tfm_alg_instance(&aead->base);
-}
-
-static inline struct crypto_blkcipher *crypto_spawn_blkcipher(
-	struct crypto_spawn *spawn)
-{
-	u32 type = CRYPTO_ALG_TYPE_BLKCIPHER;
-	u32 mask = CRYPTO_ALG_TYPE_MASK;
-
-	return __crypto_blkcipher_cast(crypto_spawn_tfm(spawn, type, mask));
-}
-
-static inline void *crypto_blkcipher_ctx(struct crypto_blkcipher *tfm)
-{
-	return crypto_tfm_ctx(&tfm->base);
-}
-
-static inline void *crypto_blkcipher_ctx_aligned(struct crypto_blkcipher *tfm)
-{
-	return crypto_tfm_ctx_aligned(&tfm->base);
-}
-
-static inline struct crypto_cipher *crypto_spawn_cipher(
-	struct crypto_spawn *spawn)
-{
-	u32 type = CRYPTO_ALG_TYPE_CIPHER;
-	u32 mask = CRYPTO_ALG_TYPE_MASK;
-
-	return __crypto_cipher_cast(crypto_spawn_tfm(spawn, type, mask));
-}
-
-static inline struct cipher_alg *crypto_cipher_alg(struct crypto_cipher *tfm)
-{
-	return &crypto_cipher_tfm(tfm)->__crt_alg->cra_cipher;
-}
-
-static inline struct crypto_hash *crypto_spawn_hash(struct crypto_spawn *spawn)
-{
-	u32 type = CRYPTO_ALG_TYPE_HASH;
-	u32 mask = CRYPTO_ALG_TYPE_HASH_MASK;
-
-	return __crypto_hash_cast(crypto_spawn_tfm(spawn, type, mask));
-}
-
-static inline void *crypto_hash_ctx(struct crypto_hash *tfm)
-{
-	return crypto_tfm_ctx(&tfm->base);
-}
-
-static inline void *crypto_hash_ctx_aligned(struct crypto_hash *tfm)
-{
-	return crypto_tfm_ctx_aligned(&tfm->base);
-}
-
-static inline void blkcipher_walk_init(struct blkcipher_walk *walk,
-				       struct scatterlist *dst,
-				       struct scatterlist *src,
-				       unsigned int nbytes)
-{
-	walk->in.sg = src;
-	walk->out.sg = dst;
-	walk->total = nbytes;
-}
-
-static inline struct crypto_async_request *crypto_get_backlog(
-	struct crypto_queue *queue)
-{
-	return queue->backlog == &queue->list ? NULL :
-	       container_of(queue->backlog, struct crypto_async_request, list);
-}
-
-static inline int ablkcipher_enqueue_request(struct crypto_queue *queue,
-					     struct ablkcipher_request *request)
-{
-	return crypto_enqueue_request(queue, &request->base);
-}
-
-static inline struct ablkcipher_request *ablkcipher_dequeue_request(
-	struct crypto_queue *queue)
-{
-	return ablkcipher_request_cast(crypto_dequeue_request(queue));
-}
-
-static inline void *ablkcipher_request_ctx(struct ablkcipher_request *req)
-{
-	return req->__ctx;
-}
-
-static inline int ablkcipher_tfm_in_queue(struct crypto_queue *queue,
-					  struct crypto_ablkcipher *tfm)
-{
-	return crypto_tfm_in_queue(queue, crypto_ablkcipher_tfm(tfm));
-}
-
-static inline void *aead_request_ctx(struct aead_request *req)
-{
-	return req->__ctx;
-}
-
-static inline void aead_request_complete(struct aead_request *req, int err)
-{
-	req->base.complete(&req->base, err);
-}
-
-static inline u32 aead_request_flags(struct aead_request *req)
-{
-	return req->base.flags;
-}
-
-static inline struct crypto_alg *crypto_get_attr_alg(struct rtattr **tb,
-						     u32 type, u32 mask)
-{
-	return crypto_attr_alg(tb[1], type, mask);
-}
-
-/*
- * Returns CRYPTO_ALG_ASYNC if type/mask requires the use of sync algorithms.
- * Otherwise returns zero.
- */
-static inline int crypto_requires_sync(u32 type, u32 mask)
-{
-	return (type ^ CRYPTO_ALG_ASYNC) & mask & CRYPTO_ALG_ASYNC;
-}
-
-#endif	/* _CRYPTO_ALGAPI_H */
-
diff --git a/libdde_linux26/contrib/include/crypto/authenc.h b/libdde_linux26/contrib/include/crypto/authenc.h
deleted file mode 100644
index e47b0449..00000000
--- a/libdde_linux26/contrib/include/crypto/authenc.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Authenc: Simple AEAD wrapper for IPsec
- *
- * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
- *
- * 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.
- *
- */
-#ifndef _CRYPTO_AUTHENC_H
-#define _CRYPTO_AUTHENC_H
-
-#include <linux/types.h>
-
-enum {
-	CRYPTO_AUTHENC_KEYA_UNSPEC,
-	CRYPTO_AUTHENC_KEYA_PARAM,
-};
-
-struct crypto_authenc_key_param {
-	__be32 enckeylen;
-};
-
-#endif	/* _CRYPTO_AUTHENC_H */
-
diff --git a/libdde_linux26/contrib/include/crypto/b128ops.h b/libdde_linux26/contrib/include/crypto/b128ops.h
deleted file mode 100644
index 0b8e6bc5..00000000
--- a/libdde_linux26/contrib/include/crypto/b128ops.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/* b128ops.h - common 128-bit block operations
- *
- * Copyright (c) 2003, Dr Brian Gladman, Worcester, UK.
- * Copyright (c) 2006, Rik Snel <rsnel@cube.dyndns.org>
- *
- * Based on Dr Brian Gladman's (GPL'd) work published at
- * http://fp.gladman.plus.com/cryptography_technology/index.htm
- * See the original copyright notice below.
- *
- * 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.
- */
-/*
- ---------------------------------------------------------------------------
- Copyright (c) 2003, Dr Brian Gladman, Worcester, UK.   All rights reserved.
-
- LICENSE TERMS
-
- The free distribution and use of this software in both source and binary
- form is allowed (with or without changes) provided that:
-
-   1. distributions of this source code include the above copyright
-      notice, this list of conditions and the following disclaimer;
-
-   2. distributions in binary form include the above copyright
-      notice, this list of conditions and the following disclaimer
-      in the documentation and/or other associated materials;
-
-   3. the copyright holder's name is not used to endorse products
-      built using this software without specific written permission.
-
- ALTERNATIVELY, provided that this notice is retained in full, this product
- may be distributed under the terms of the GNU General Public License (GPL),
- in which case the provisions of the GPL apply INSTEAD OF those given above.
-
- DISCLAIMER
-
- This software is provided 'as is' with no explicit or implied warranties
- in respect of its properties, including, but not limited to, correctness
- and/or fitness for purpose.
- ---------------------------------------------------------------------------
- Issue Date: 13/06/2006
-*/
-
-#ifndef _CRYPTO_B128OPS_H
-#define _CRYPTO_B128OPS_H
-
-#include <linux/types.h>
-
-typedef struct {
-	u64 a, b;
-} u128;
-
-typedef struct {
-	__be64 a, b;
-} be128;
-
-typedef struct {
-	__le64 b, a;
-} le128;
-
-static inline void u128_xor(u128 *r, const u128 *p, const u128 *q)
-{
-	r->a = p->a ^ q->a;
-	r->b = p->b ^ q->b;
-}
-
-static inline void be128_xor(be128 *r, const be128 *p, const be128 *q)
-{
-	u128_xor((u128 *)r, (u128 *)p, (u128 *)q);
-}
-
-static inline void le128_xor(le128 *r, const le128 *p, const le128 *q)
-{
-	u128_xor((u128 *)r, (u128 *)p, (u128 *)q);
-}
-
-#endif /* _CRYPTO_B128OPS_H */
diff --git a/libdde_linux26/contrib/include/crypto/ctr.h b/libdde_linux26/contrib/include/crypto/ctr.h
deleted file mode 100644
index 4180fc08..00000000
--- a/libdde_linux26/contrib/include/crypto/ctr.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * CTR: Counter mode
- *
- * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
- *
- * 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.
- *
- */
-
-#ifndef _CRYPTO_CTR_H
-#define _CRYPTO_CTR_H
-
-#define CTR_RFC3686_NONCE_SIZE 4
-#define CTR_RFC3686_IV_SIZE 8
-#define CTR_RFC3686_BLOCK_SIZE 16
-
-#endif  /* _CRYPTO_CTR_H */
diff --git a/libdde_linux26/contrib/include/crypto/des.h b/libdde_linux26/contrib/include/crypto/des.h
deleted file mode 100644
index 2971c630..00000000
--- a/libdde_linux26/contrib/include/crypto/des.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/* 
- * DES & Triple DES EDE Cipher Algorithms.
- */
-
-#ifndef __CRYPTO_DES_H
-#define __CRYPTO_DES_H
-
-#define DES_KEY_SIZE		8
-#define DES_EXPKEY_WORDS	32
-#define DES_BLOCK_SIZE		8
-
-#define DES3_EDE_KEY_SIZE	(3 * DES_KEY_SIZE)
-#define DES3_EDE_EXPKEY_WORDS	(3 * DES_EXPKEY_WORDS)
-#define DES3_EDE_BLOCK_SIZE	DES_BLOCK_SIZE
-
-
-extern unsigned long des_ekey(u32 *pe, const u8 *k);
-
-#endif /* __CRYPTO_DES_H */
diff --git a/libdde_linux26/contrib/include/crypto/gf128mul.h b/libdde_linux26/contrib/include/crypto/gf128mul.h
deleted file mode 100644
index 4086b8eb..00000000
--- a/libdde_linux26/contrib/include/crypto/gf128mul.h
+++ /dev/null
@@ -1,200 +0,0 @@
-/* gf128mul.h - GF(2^128) multiplication functions
- *
- * Copyright (c) 2003, Dr Brian Gladman, Worcester, UK.
- * Copyright (c) 2006 Rik Snel <rsnel@cube.dyndns.org>
- *
- * Based on Dr Brian Gladman's (GPL'd) work published at
- * http://fp.gladman.plus.com/cryptography_technology/index.htm
- * See the original copyright notice below.
- *
- * 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.
- */
-/*
- ---------------------------------------------------------------------------
- Copyright (c) 2003, Dr Brian Gladman, Worcester, UK.   All rights reserved.
-
- LICENSE TERMS
-
- The free distribution and use of this software in both source and binary
- form is allowed (with or without changes) provided that:
-
-   1. distributions of this source code include the above copyright
-      notice, this list of conditions and the following disclaimer;
-
-   2. distributions in binary form include the above copyright
-      notice, this list of conditions and the following disclaimer
-      in the documentation and/or other associated materials;
-
-   3. the copyright holder's name is not used to endorse products
-      built using this software without specific written permission.
-
- ALTERNATIVELY, provided that this notice is retained in full, this product
- may be distributed under the terms of the GNU General Public License (GPL),
- in which case the provisions of the GPL apply INSTEAD OF those given above.
-
- DISCLAIMER
-
- This software is provided 'as is' with no explicit or implied warranties
- in respect of its properties, including, but not limited to, correctness
- and/or fitness for purpose.
- ---------------------------------------------------------------------------
- Issue Date: 31/01/2006
-
- An implementation of field multiplication in Galois Field GF(128)
-*/
-
-#ifndef _CRYPTO_GF128MUL_H
-#define _CRYPTO_GF128MUL_H
-
-#include <crypto/b128ops.h>
-#include <linux/slab.h>
-
-/* Comment by Rik:
- *
- * For some background on GF(2^128) see for example: http://-
- * csrc.nist.gov/CryptoToolkit/modes/proposedmodes/gcm/gcm-revised-spec.pdf
- *
- * The elements of GF(2^128) := GF(2)[X]/(X^128-X^7-X^2-X^1-1) can
- * be mapped to computer memory in a variety of ways. Let's examine
- * three common cases.
- *
- * Take a look at the 16 binary octets below in memory order. The msb's
- * are left and the lsb's are right. char b[16] is an array and b[0] is
- * the first octet.
- *
- * 80000000 00000000 00000000 00000000 .... 00000000 00000000 00000000
- *   b[0]     b[1]     b[2]     b[3]          b[13]    b[14]    b[15]
- *
- * Every bit is a coefficient of some power of X. We can store the bits
- * in every byte in little-endian order and the bytes themselves also in
- * little endian order. I will call this lle (little-little-endian).
- * The above buffer represents the polynomial 1, and X^7+X^2+X^1+1 looks
- * like 11100001 00000000 .... 00000000 = { 0xE1, 0x00, }.
- * This format was originally implemented in gf128mul and is used
- * in GCM (Galois/Counter mode) and in ABL (Arbitrary Block Length).
- *
- * Another convention says: store the bits in bigendian order and the
- * bytes also. This is bbe (big-big-endian). Now the buffer above
- * represents X^127. X^7+X^2+X^1+1 looks like 00000000 .... 10000111,
- * b[15] = 0x87 and the rest is 0. LRW uses this convention and bbe
- * is partly implemented.
- *
- * Both of the above formats are easy to implement on big-endian
- * machines.
- *
- * EME (which is patent encumbered) uses the ble format (bits are stored
- * in big endian order and the bytes in little endian). The above buffer
- * represents X^7 in this case and the primitive polynomial is b[0] = 0x87.
- *
- * The common machine word-size is smaller than 128 bits, so to make
- * an efficient implementation we must split into machine word sizes.
- * This file uses one 32bit for the moment. Machine endianness comes into
- * play. The lle format in relation to machine endianness is discussed
- * below by the original author of gf128mul Dr Brian Gladman.
- *
- * Let's look at the bbe and ble format on a little endian machine.
- *
- * bbe on a little endian machine u32 x[4]:
- *
- *  MS            x[0]           LS  MS            x[1]		  LS
- *  ms   ls ms   ls ms   ls ms   ls  ms   ls ms   ls ms   ls ms   ls
- *  103..96 111.104 119.112 127.120  71...64 79...72 87...80 95...88
- *
- *  MS            x[2]           LS  MS            x[3]		  LS
- *  ms   ls ms   ls ms   ls ms   ls  ms   ls ms   ls ms   ls ms   ls
- *  39...32 47...40 55...48 63...56  07...00 15...08 23...16 31...24
- *
- * ble on a little endian machine
- *
- *  MS            x[0]           LS  MS            x[1]		  LS
- *  ms   ls ms   ls ms   ls ms   ls  ms   ls ms   ls ms   ls ms   ls
- *  31...24 23...16 15...08 07...00  63...56 55...48 47...40 39...32
- *
- *  MS            x[2]           LS  MS            x[3]		  LS
- *  ms   ls ms   ls ms   ls ms   ls  ms   ls ms   ls ms   ls ms   ls
- *  95...88 87...80 79...72 71...64  127.120 199.112 111.104 103..96
- *
- * Multiplications in GF(2^128) are mostly bit-shifts, so you see why
- * ble (and lbe also) are easier to implement on a little-endian
- * machine than on a big-endian machine. The converse holds for bbe
- * and lle.
- *
- * Note: to have good alignment, it seems to me that it is sufficient
- * to keep elements of GF(2^128) in type u64[2]. On 32-bit wordsize
- * machines this will automatically aligned to wordsize and on a 64-bit
- * machine also.
- */
-/*	Multiply a GF128 field element by x. Field elements are held in arrays
-    of bytes in which field bits 8n..8n + 7 are held in byte[n], with lower
-    indexed bits placed in the more numerically significant bit positions
-    within bytes.
-
-    On little endian machines the bit indexes translate into the bit
-    positions within four 32-bit words in the following way
-
-    MS            x[0]           LS  MS            x[1]		  LS
-    ms   ls ms   ls ms   ls ms   ls  ms   ls ms   ls ms   ls ms   ls
-    24...31 16...23 08...15 00...07  56...63 48...55 40...47 32...39
-
-    MS            x[2]           LS  MS            x[3]		  LS
-    ms   ls ms   ls ms   ls ms   ls  ms   ls ms   ls ms   ls ms   ls
-    88...95 80...87 72...79 64...71  120.127 112.119 104.111 96..103
-
-    On big endian machines the bit indexes translate into the bit
-    positions within four 32-bit words in the following way
-
-    MS            x[0]           LS  MS            x[1]		  LS
-    ms   ls ms   ls ms   ls ms   ls  ms   ls ms   ls ms   ls ms   ls
-    00...07 08...15 16...23 24...31  32...39 40...47 48...55 56...63
-
-    MS            x[2]           LS  MS            x[3]		  LS
-    ms   ls ms   ls ms   ls ms   ls  ms   ls ms   ls ms   ls ms   ls
-    64...71 72...79 80...87 88...95  96..103 104.111 112.119 120.127
-*/
-
-/*	A slow generic version of gf_mul, implemented for lle and bbe
- * 	It multiplies a and b and puts the result in a */
-void gf128mul_lle(be128 *a, const be128 *b);
-
-void gf128mul_bbe(be128 *a, const be128 *b);
-
-/* multiply by x in ble format, needed by XTS */
-void gf128mul_x_ble(be128 *a, const be128 *b);
-
-/* 4k table optimization */
-
-struct gf128mul_4k {
-	be128 t[256];
-};
-
-struct gf128mul_4k *gf128mul_init_4k_lle(const be128 *g);
-struct gf128mul_4k *gf128mul_init_4k_bbe(const be128 *g);
-void gf128mul_4k_lle(be128 *a, struct gf128mul_4k *t);
-void gf128mul_4k_bbe(be128 *a, struct gf128mul_4k *t);
-
-static inline void gf128mul_free_4k(struct gf128mul_4k *t)
-{
-	kfree(t);
-}
-
-
-/* 64k table optimization, implemented for lle and bbe */
-
-struct gf128mul_64k {
-	struct gf128mul_4k *t[16];
-};
-
-/* first initialize with the constant factor with which you
- * want to multiply and then call gf128_64k_lle with the other
- * factor in the first argument, the table in the second and a
- * scratch register in the third. Afterwards *a = *r. */
-struct gf128mul_64k *gf128mul_init_64k_lle(const be128 *g);
-struct gf128mul_64k *gf128mul_init_64k_bbe(const be128 *g);
-void gf128mul_free_64k(struct gf128mul_64k *t);
-void gf128mul_64k_lle(be128 *a, struct gf128mul_64k *t);
-void gf128mul_64k_bbe(be128 *a, struct gf128mul_64k *t);
-
-#endif /* _CRYPTO_GF128MUL_H */
diff --git a/libdde_linux26/contrib/include/crypto/hash.h b/libdde_linux26/contrib/include/crypto/hash.h
deleted file mode 100644
index d797e119..00000000
--- a/libdde_linux26/contrib/include/crypto/hash.h
+++ /dev/null
@@ -1,297 +0,0 @@
-/*
- * Hash: Hash algorithms under the crypto API
- * 
- * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
- *
- * 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.
- *
- */
-
-#ifndef _CRYPTO_HASH_H
-#define _CRYPTO_HASH_H
-
-#include <linux/crypto.h>
-
-struct shash_desc {
-	struct crypto_shash *tfm;
-	u32 flags;
-
-	void *__ctx[] CRYPTO_MINALIGN_ATTR;
-};
-
-struct shash_alg {
-	int (*init)(struct shash_desc *desc);
-	int (*reinit)(struct shash_desc *desc);
-	int (*update)(struct shash_desc *desc, const u8 *data,
-		      unsigned int len);
-	int (*final)(struct shash_desc *desc, u8 *out);
-	int (*finup)(struct shash_desc *desc, const u8 *data,
-		     unsigned int len, u8 *out);
-	int (*digest)(struct shash_desc *desc, const u8 *data,
-		      unsigned int len, u8 *out);
-	int (*setkey)(struct crypto_shash *tfm, const u8 *key,
-		      unsigned int keylen);
-
-	unsigned int descsize;
-	unsigned int digestsize;
-
-	struct crypto_alg base;
-};
-
-struct crypto_ahash {
-	struct crypto_tfm base;
-};
-
-struct crypto_shash {
-	struct crypto_tfm base;
-};
-
-static inline struct crypto_ahash *__crypto_ahash_cast(struct crypto_tfm *tfm)
-{
-	return (struct crypto_ahash *)tfm;
-}
-
-static inline struct crypto_ahash *crypto_alloc_ahash(const char *alg_name,
-						      u32 type, u32 mask)
-{
-	type &= ~CRYPTO_ALG_TYPE_MASK;
-	mask &= ~CRYPTO_ALG_TYPE_MASK;
-	type |= CRYPTO_ALG_TYPE_AHASH;
-	mask |= CRYPTO_ALG_TYPE_AHASH_MASK;
-
-	return __crypto_ahash_cast(crypto_alloc_base(alg_name, type, mask));
-}
-
-static inline struct crypto_tfm *crypto_ahash_tfm(struct crypto_ahash *tfm)
-{
-	return &tfm->base;
-}
-
-static inline void crypto_free_ahash(struct crypto_ahash *tfm)
-{
-	crypto_free_tfm(crypto_ahash_tfm(tfm));
-}
-
-static inline unsigned int crypto_ahash_alignmask(
-	struct crypto_ahash *tfm)
-{
-	return crypto_tfm_alg_alignmask(crypto_ahash_tfm(tfm));
-}
-
-static inline struct ahash_tfm *crypto_ahash_crt(struct crypto_ahash *tfm)
-{
-	return &crypto_ahash_tfm(tfm)->crt_ahash;
-}
-
-static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)
-{
-	return crypto_ahash_crt(tfm)->digestsize;
-}
-
-static inline u32 crypto_ahash_get_flags(struct crypto_ahash *tfm)
-{
-	return crypto_tfm_get_flags(crypto_ahash_tfm(tfm));
-}
-
-static inline void crypto_ahash_set_flags(struct crypto_ahash *tfm, u32 flags)
-{
-	crypto_tfm_set_flags(crypto_ahash_tfm(tfm), flags);
-}
-
-static inline void crypto_ahash_clear_flags(struct crypto_ahash *tfm, u32 flags)
-{
-	crypto_tfm_clear_flags(crypto_ahash_tfm(tfm), flags);
-}
-
-static inline struct crypto_ahash *crypto_ahash_reqtfm(
-	struct ahash_request *req)
-{
-	return __crypto_ahash_cast(req->base.tfm);
-}
-
-static inline unsigned int crypto_ahash_reqsize(struct crypto_ahash *tfm)
-{
-	return crypto_ahash_crt(tfm)->reqsize;
-}
-
-static inline void *ahash_request_ctx(struct ahash_request *req)
-{
-	return req->__ctx;
-}
-
-static inline int crypto_ahash_setkey(struct crypto_ahash *tfm,
-				      const u8 *key, unsigned int keylen)
-{
-	struct ahash_tfm *crt = crypto_ahash_crt(tfm);
-
-	return crt->setkey(tfm, key, keylen);
-}
-
-static inline int crypto_ahash_digest(struct ahash_request *req)
-{
-	struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
-	return crt->digest(req);
-}
-
-static inline void crypto_ahash_export(struct ahash_request *req, u8 *out)
-{
-	memcpy(out, ahash_request_ctx(req),
-	       crypto_ahash_reqsize(crypto_ahash_reqtfm(req)));
-}
-
-int crypto_ahash_import(struct ahash_request *req, const u8 *in);
-
-static inline int crypto_ahash_init(struct ahash_request *req)
-{
-	struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
-	return crt->init(req);
-}
-
-static inline int crypto_ahash_update(struct ahash_request *req)
-{
-	struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
-	return crt->update(req);
-}
-
-static inline int crypto_ahash_final(struct ahash_request *req)
-{
-	struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
-	return crt->final(req);
-}
-
-static inline void ahash_request_set_tfm(struct ahash_request *req,
-					 struct crypto_ahash *tfm)
-{
-	req->base.tfm = crypto_ahash_tfm(tfm);
-}
-
-static inline struct ahash_request *ahash_request_alloc(
-	struct crypto_ahash *tfm, gfp_t gfp)
-{
-	struct ahash_request *req;
-
-	req = kmalloc(sizeof(struct ahash_request) +
-		      crypto_ahash_reqsize(tfm), gfp);
-
-	if (likely(req))
-		ahash_request_set_tfm(req, tfm);
-
-	return req;
-}
-
-static inline void ahash_request_free(struct ahash_request *req)
-{
-	kfree(req);
-}
-
-static inline struct ahash_request *ahash_request_cast(
-	struct crypto_async_request *req)
-{
-	return container_of(req, struct ahash_request, base);
-}
-
-static inline void ahash_request_set_callback(struct ahash_request *req,
-					      u32 flags,
-					      crypto_completion_t complete,
-					      void *data)
-{
-	req->base.complete = complete;
-	req->base.data = data;
-	req->base.flags = flags;
-}
-
-static inline void ahash_request_set_crypt(struct ahash_request *req,
-					   struct scatterlist *src, u8 *result,
-					   unsigned int nbytes)
-{
-	req->src = src;
-	req->nbytes = nbytes;
-	req->result = result;
-}
-
-struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
-					u32 mask);
-
-static inline struct crypto_tfm *crypto_shash_tfm(struct crypto_shash *tfm)
-{
-	return &tfm->base;
-}
-
-static inline void crypto_free_shash(struct crypto_shash *tfm)
-{
-	crypto_destroy_tfm(tfm, crypto_shash_tfm(tfm));
-}
-
-static inline unsigned int crypto_shash_alignmask(
-	struct crypto_shash *tfm)
-{
-	return crypto_tfm_alg_alignmask(crypto_shash_tfm(tfm));
-}
-
-static inline struct shash_alg *__crypto_shash_alg(struct crypto_alg *alg)
-{
-	return container_of(alg, struct shash_alg, base);
-}
-
-static inline struct shash_alg *crypto_shash_alg(struct crypto_shash *tfm)
-{
-	return __crypto_shash_alg(crypto_shash_tfm(tfm)->__crt_alg);
-}
-
-static inline unsigned int crypto_shash_digestsize(struct crypto_shash *tfm)
-{
-	return crypto_shash_alg(tfm)->digestsize;
-}
-
-static inline u32 crypto_shash_get_flags(struct crypto_shash *tfm)
-{
-	return crypto_tfm_get_flags(crypto_shash_tfm(tfm));
-}
-
-static inline void crypto_shash_set_flags(struct crypto_shash *tfm, u32 flags)
-{
-	crypto_tfm_set_flags(crypto_shash_tfm(tfm), flags);
-}
-
-static inline void crypto_shash_clear_flags(struct crypto_shash *tfm, u32 flags)
-{
-	crypto_tfm_clear_flags(crypto_shash_tfm(tfm), flags);
-}
-
-static inline unsigned int crypto_shash_descsize(struct crypto_shash *tfm)
-{
-	return crypto_shash_alg(tfm)->descsize;
-}
-
-static inline void *shash_desc_ctx(struct shash_desc *desc)
-{
-	return desc->__ctx;
-}
-
-int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
-			unsigned int keylen);
-int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
-			unsigned int len, u8 *out);
-
-static inline void crypto_shash_export(struct shash_desc *desc, u8 *out)
-{
-	memcpy(out, shash_desc_ctx(desc), crypto_shash_descsize(desc->tfm));
-}
-
-int crypto_shash_import(struct shash_desc *desc, const u8 *in);
-
-static inline int crypto_shash_init(struct shash_desc *desc)
-{
-	return crypto_shash_alg(desc->tfm)->init(desc);
-}
-
-int crypto_shash_update(struct shash_desc *desc, const u8 *data,
-			unsigned int len);
-int crypto_shash_final(struct shash_desc *desc, u8 *out);
-int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
-		       unsigned int len, u8 *out);
-
-#endif	/* _CRYPTO_HASH_H */
diff --git a/libdde_linux26/contrib/include/crypto/rng.h b/libdde_linux26/contrib/include/crypto/rng.h
deleted file mode 100644
index c93f9b91..00000000
--- a/libdde_linux26/contrib/include/crypto/rng.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * RNG: Random Number Generator  algorithms under the crypto API
- *
- * Copyright (c) 2008 Neil Horman <nhorman@tuxdriver.com>
- *
- * 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.
- *
- */
-
-#ifndef _CRYPTO_RNG_H
-#define _CRYPTO_RNG_H
-
-#include <linux/crypto.h>
-
-extern struct crypto_rng *crypto_default_rng;
-
-int crypto_get_default_rng(void);
-void crypto_put_default_rng(void);
-
-static inline struct crypto_rng *__crypto_rng_cast(struct crypto_tfm *tfm)
-{
-	return (struct crypto_rng *)tfm;
-}
-
-static inline struct crypto_rng *crypto_alloc_rng(const char *alg_name,
-						  u32 type, u32 mask)
-{
-	type &= ~CRYPTO_ALG_TYPE_MASK;
-	type |= CRYPTO_ALG_TYPE_RNG;
-	mask |= CRYPTO_ALG_TYPE_MASK;
-
-	return __crypto_rng_cast(crypto_alloc_base(alg_name, type, mask));
-}
-
-static inline struct crypto_tfm *crypto_rng_tfm(struct crypto_rng *tfm)
-{
-	return &tfm->base;
-}
-
-static inline struct rng_alg *crypto_rng_alg(struct crypto_rng *tfm)
-{
-	return &crypto_rng_tfm(tfm)->__crt_alg->cra_rng;
-}
-
-static inline struct rng_tfm *crypto_rng_crt(struct crypto_rng *tfm)
-{
-	return &crypto_rng_tfm(tfm)->crt_rng;
-}
-
-static inline void crypto_free_rng(struct crypto_rng *tfm)
-{
-	crypto_free_tfm(crypto_rng_tfm(tfm));
-}
-
-static inline int crypto_rng_get_bytes(struct crypto_rng *tfm,
-				       u8 *rdata, unsigned int dlen)
-{
-	return crypto_rng_crt(tfm)->rng_gen_random(tfm, rdata, dlen);
-}
-
-static inline int crypto_rng_reset(struct crypto_rng *tfm,
-				   u8 *seed, unsigned int slen)
-{
-	return crypto_rng_crt(tfm)->rng_reset(tfm, seed, slen);
-}
-
-static inline int crypto_rng_seedsize(struct crypto_rng *tfm)
-{
-	return crypto_rng_alg(tfm)->seedsize;
-}
-
-#endif
diff --git a/libdde_linux26/contrib/include/crypto/scatterwalk.h b/libdde_linux26/contrib/include/crypto/scatterwalk.h
deleted file mode 100644
index 833d208c..00000000
--- a/libdde_linux26/contrib/include/crypto/scatterwalk.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Cryptographic scatter and gather helpers.
- *
- * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
- * Copyright (c) 2002 Adam J. Richter <adam@yggdrasil.com>
- * Copyright (c) 2004 Jean-Luc Cooke <jlcooke@certainkey.com>
- * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
- *
- * 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.
- *
- */
-
-#ifndef _CRYPTO_SCATTERWALK_H
-#define _CRYPTO_SCATTERWALK_H
-
-#include <asm/kmap_types.h>
-#include <crypto/algapi.h>
-#include <linux/hardirq.h>
-#include <linux/highmem.h>
-#include <linux/kernel.h>
-#include <linux/mm.h>
-#include <linux/scatterlist.h>
-#include <linux/sched.h>
-
-static inline enum km_type crypto_kmap_type(int out)
-{
-	enum km_type type;
-
-	if (in_softirq())
-		type = out * (KM_SOFTIRQ1 - KM_SOFTIRQ0) + KM_SOFTIRQ0;
-	else
-		type = out * (KM_USER1 - KM_USER0) + KM_USER0;
-
-	return type;
-}
-
-static inline void *crypto_kmap(struct page *page, int out)
-{
-	return kmap_atomic(page, crypto_kmap_type(out));
-}
-
-static inline void crypto_kunmap(void *vaddr, int out)
-{
-	kunmap_atomic(vaddr, crypto_kmap_type(out));
-}
-
-static inline void crypto_yield(u32 flags)
-{
-	if (flags & CRYPTO_TFM_REQ_MAY_SLEEP)
-		cond_resched();
-}
-
-static inline void scatterwalk_sg_chain(struct scatterlist *sg1, int num,
-					struct scatterlist *sg2)
-{
-	sg_set_page(&sg1[num - 1], (void *)sg2, 0, 0);
-	sg1[num - 1].page_link &= ~0x02;
-}
-
-static inline struct scatterlist *scatterwalk_sg_next(struct scatterlist *sg)
-{
-	if (sg_is_last(sg))
-		return NULL;
-
-	return (++sg)->length ? sg : (void *)sg_page(sg);
-}
-
-static inline unsigned long scatterwalk_samebuf(struct scatter_walk *walk_in,
-						struct scatter_walk *walk_out)
-{
-	return !(((sg_page(walk_in->sg) - sg_page(walk_out->sg)) << PAGE_SHIFT) +
-		 (int)(walk_in->offset - walk_out->offset));
-}
-
-static inline unsigned int scatterwalk_pagelen(struct scatter_walk *walk)
-{
-	unsigned int len = walk->sg->offset + walk->sg->length - walk->offset;
-	unsigned int len_this_page = offset_in_page(~walk->offset) + 1;
-	return len_this_page > len ? len : len_this_page;
-}
-
-static inline unsigned int scatterwalk_clamp(struct scatter_walk *walk,
-					     unsigned int nbytes)
-{
-	unsigned int len_this_page = scatterwalk_pagelen(walk);
-	return nbytes > len_this_page ? len_this_page : nbytes;
-}
-
-static inline void scatterwalk_advance(struct scatter_walk *walk,
-				       unsigned int nbytes)
-{
-	walk->offset += nbytes;
-}
-
-static inline unsigned int scatterwalk_aligned(struct scatter_walk *walk,
-					       unsigned int alignmask)
-{
-	return !(walk->offset & alignmask);
-}
-
-static inline struct page *scatterwalk_page(struct scatter_walk *walk)
-{
-	return sg_page(walk->sg) + (walk->offset >> PAGE_SHIFT);
-}
-
-static inline void scatterwalk_unmap(void *vaddr, int out)
-{
-	crypto_kunmap(vaddr, out);
-}
-
-void scatterwalk_start(struct scatter_walk *walk, struct scatterlist *sg);
-void scatterwalk_copychunks(void *buf, struct scatter_walk *walk,
-			    size_t nbytes, int out);
-void *scatterwalk_map(struct scatter_walk *walk, int out);
-void scatterwalk_done(struct scatter_walk *walk, int out, int more);
-
-void scatterwalk_map_and_copy(void *buf, struct scatterlist *sg,
-			      unsigned int start, unsigned int nbytes, int out);
-
-#endif  /* _CRYPTO_SCATTERWALK_H */
diff --git a/libdde_linux26/contrib/include/crypto/sha.h b/libdde_linux26/contrib/include/crypto/sha.h
deleted file mode 100644
index c0ccc2b1..00000000
--- a/libdde_linux26/contrib/include/crypto/sha.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Common values for SHA algorithms
- */
-
-#ifndef _CRYPTO_SHA_H
-#define _CRYPTO_SHA_H
-
-#define SHA1_DIGEST_SIZE        20
-#define SHA1_BLOCK_SIZE         64
-
-#define SHA224_DIGEST_SIZE	28
-#define SHA224_BLOCK_SIZE	64
-
-#define SHA256_DIGEST_SIZE      32
-#define SHA256_BLOCK_SIZE       64
-
-#define SHA384_DIGEST_SIZE      48
-#define SHA384_BLOCK_SIZE       128
-
-#define SHA512_DIGEST_SIZE      64
-#define SHA512_BLOCK_SIZE       128
-
-#define SHA1_H0		0x67452301UL
-#define SHA1_H1		0xefcdab89UL
-#define SHA1_H2		0x98badcfeUL
-#define SHA1_H3		0x10325476UL
-#define SHA1_H4		0xc3d2e1f0UL
-
-#define SHA224_H0	0xc1059ed8UL
-#define SHA224_H1	0x367cd507UL
-#define SHA224_H2	0x3070dd17UL
-#define SHA224_H3	0xf70e5939UL
-#define SHA224_H4	0xffc00b31UL
-#define SHA224_H5	0x68581511UL
-#define SHA224_H6	0x64f98fa7UL
-#define SHA224_H7	0xbefa4fa4UL
-
-#define SHA256_H0	0x6a09e667UL
-#define SHA256_H1	0xbb67ae85UL
-#define SHA256_H2	0x3c6ef372UL
-#define SHA256_H3	0xa54ff53aUL
-#define SHA256_H4	0x510e527fUL
-#define SHA256_H5	0x9b05688cUL
-#define SHA256_H6	0x1f83d9abUL
-#define SHA256_H7	0x5be0cd19UL
-
-#define SHA384_H0	0xcbbb9d5dc1059ed8ULL
-#define SHA384_H1	0x629a292a367cd507ULL
-#define SHA384_H2	0x9159015a3070dd17ULL
-#define SHA384_H3	0x152fecd8f70e5939ULL
-#define SHA384_H4	0x67332667ffc00b31ULL
-#define SHA384_H5	0x8eb44a8768581511ULL
-#define SHA384_H6	0xdb0c2e0d64f98fa7ULL
-#define SHA384_H7	0x47b5481dbefa4fa4ULL
-
-#define SHA512_H0	0x6a09e667f3bcc908ULL
-#define SHA512_H1	0xbb67ae8584caa73bULL
-#define SHA512_H2	0x3c6ef372fe94f82bULL
-#define SHA512_H3	0xa54ff53a5f1d36f1ULL
-#define SHA512_H4	0x510e527fade682d1ULL
-#define SHA512_H5	0x9b05688c2b3e6c1fULL
-#define SHA512_H6	0x1f83d9abfb41bd6bULL
-#define SHA512_H7	0x5be0cd19137e2179ULL
-
-#endif
diff --git a/libdde_linux26/contrib/include/crypto/skcipher.h b/libdde_linux26/contrib/include/crypto/skcipher.h
deleted file mode 100644
index 25fd6126..00000000
--- a/libdde_linux26/contrib/include/crypto/skcipher.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * Symmetric key ciphers.
- * 
- * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
- *
- * 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.
- *
- */
-
-#ifndef _CRYPTO_SKCIPHER_H
-#define _CRYPTO_SKCIPHER_H
-
-#include <linux/crypto.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-
-/**
- *	struct skcipher_givcrypt_request - Crypto request with IV generation
- *	@seq: Sequence number for IV generation
- *	@giv: Space for generated IV
- *	@creq: The crypto request itself
- */
-struct skcipher_givcrypt_request {
-	u64 seq;
-	u8 *giv;
-
-	struct ablkcipher_request creq;
-};
-
-static inline struct crypto_ablkcipher *skcipher_givcrypt_reqtfm(
-	struct skcipher_givcrypt_request *req)
-{
-	return crypto_ablkcipher_reqtfm(&req->creq);
-}
-
-static inline int crypto_skcipher_givencrypt(
-	struct skcipher_givcrypt_request *req)
-{
-	struct ablkcipher_tfm *crt =
-		crypto_ablkcipher_crt(skcipher_givcrypt_reqtfm(req));
-	return crt->givencrypt(req);
-};
-
-static inline int crypto_skcipher_givdecrypt(
-	struct skcipher_givcrypt_request *req)
-{
-	struct ablkcipher_tfm *crt =
-		crypto_ablkcipher_crt(skcipher_givcrypt_reqtfm(req));
-	return crt->givdecrypt(req);
-};
-
-static inline void skcipher_givcrypt_set_tfm(
-	struct skcipher_givcrypt_request *req, struct crypto_ablkcipher *tfm)
-{
-	req->creq.base.tfm = crypto_ablkcipher_tfm(tfm);
-}
-
-static inline struct skcipher_givcrypt_request *skcipher_givcrypt_cast(
-	struct crypto_async_request *req)
-{
-	return container_of(ablkcipher_request_cast(req),
-			    struct skcipher_givcrypt_request, creq);
-}
-
-static inline struct skcipher_givcrypt_request *skcipher_givcrypt_alloc(
-	struct crypto_ablkcipher *tfm, gfp_t gfp)
-{
-	struct skcipher_givcrypt_request *req;
-
-	req = kmalloc(sizeof(struct skcipher_givcrypt_request) +
-		      crypto_ablkcipher_reqsize(tfm), gfp);
-
-	if (likely(req))
-		skcipher_givcrypt_set_tfm(req, tfm);
-
-	return req;
-}
-
-static inline void skcipher_givcrypt_free(struct skcipher_givcrypt_request *req)
-{
-	kfree(req);
-}
-
-static inline void skcipher_givcrypt_set_callback(
-	struct skcipher_givcrypt_request *req, u32 flags,
-	crypto_completion_t complete, void *data)
-{
-	ablkcipher_request_set_callback(&req->creq, flags, complete, data);
-}
-
-static inline void skcipher_givcrypt_set_crypt(
-	struct skcipher_givcrypt_request *req,
-	struct scatterlist *src, struct scatterlist *dst,
-	unsigned int nbytes, void *iv)
-{
-	ablkcipher_request_set_crypt(&req->creq, src, dst, nbytes, iv);
-}
-
-static inline void skcipher_givcrypt_set_giv(
-	struct skcipher_givcrypt_request *req, u8 *giv, u64 seq)
-{
-	req->giv = giv;
-	req->seq = seq;
-}
-
-#endif	/* _CRYPTO_SKCIPHER_H */
-
diff --git a/libdde_linux26/contrib/include/crypto/twofish.h b/libdde_linux26/contrib/include/crypto/twofish.h
deleted file mode 100644
index c4085225..00000000
--- a/libdde_linux26/contrib/include/crypto/twofish.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef _CRYPTO_TWOFISH_H
-#define _CRYPTO_TWOFISH_H
-
-#include <linux/types.h>
-
-#define TF_MIN_KEY_SIZE 16
-#define TF_MAX_KEY_SIZE 32
-#define TF_BLOCK_SIZE 16
-
-struct crypto_tfm;
-
-/* Structure for an expanded Twofish key.  s contains the key-dependent
- * S-boxes composed with the MDS matrix; w contains the eight "whitening"
- * subkeys, K[0] through K[7].	k holds the remaining, "round" subkeys.  Note
- * that k[i] corresponds to what the Twofish paper calls K[i+8]. */
-struct twofish_ctx {
-	u32 s[4][256], w[8], k[32];
-};
-
-int twofish_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int key_len);
-
-#endif