* Re: [PATCH dt V2] ARM: BCM5301X: Enable UART by default for BCM4708(1), BCM4709(4) & BCM53012
From: Hauke Mehrtens @ 2016-12-04 19:08 UTC (permalink / raw)
To: Rafał Miłecki, Florian Fainelli
Cc: Rob Herring, Mark Rutland, Russell King,
bcm-kernel-feedback-list-dY08KVG/lbpWk0Htik3J/w,
devicetree-u79uwXL29TY76Z2rM5mHXA,
linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r,
linux-kernel-u79uwXL29TY76Z2rM5mHXA, Rafał Miłecki
In-Reply-To: <20161201174051.4965-1-zajec5-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>
On 12/01/2016 06:40 PM, Rafał Miłecki wrote:
> From: Rafał Miłecki <rafal-g1n6cQUeyibVItvQsEIGlw@public.gmane.org>
>
> Every device tested so far got UART0 (at 0x18000300) working as serial
> console. It's most likely part of reference design and all vendors use
> it that way.
I think the last 4 boards are some of the reference boards. ;-)
> It seems to be easier to enable it by default and just disable it if we
> ever see a device with different hardware design.
>
> Signed-off-by: Rafał Miłecki <rafal-g1n6cQUeyibVItvQsEIGlw@public.gmane.org>
Acked-by: Hauke Mehrtens <hauke-5/S+JYg5SzeELgA04lAiVw@public.gmane.org>
> ---
> V2: Update bcm94708.dts bcm94709.dts bcm953012er.dts & bcm953012k.dts
> ---
> arch/arm/boot/dts/bcm4708-buffalo-wzr-1750dhp.dts | 4 ----
> arch/arm/boot/dts/bcm4708-luxul-xap-1510.dts | 4 ----
> arch/arm/boot/dts/bcm4708-luxul-xwc-1000.dts | 4 ----
> arch/arm/boot/dts/bcm4708-netgear-r6250.dts | 4 ----
> arch/arm/boot/dts/bcm4708-smartrg-sr400ac.dts | 4 ----
> arch/arm/boot/dts/bcm4708.dtsi | 4 ++++
> arch/arm/boot/dts/bcm47081-buffalo-wzr-600dhp2.dts | 4 ----
> arch/arm/boot/dts/bcm47081.dtsi | 4 ++++
> arch/arm/boot/dts/bcm4709-netgear-r7000.dts | 4 ----
> arch/arm/boot/dts/bcm4709-netgear-r8000.dts | 4 ----
> arch/arm/boot/dts/bcm4709-tplink-archer-c9-v1.dts | 4 ----
> arch/arm/boot/dts/bcm4709.dtsi | 1 +
> arch/arm/boot/dts/bcm47094-dlink-dir-885l.dts | 4 ----
> arch/arm/boot/dts/bcm47094-luxul-xwr-3100.dts | 4 ----
> arch/arm/boot/dts/bcm47094-netgear-r8500.dts | 4 ----
> arch/arm/boot/dts/bcm47094.dtsi | 1 +
> arch/arm/boot/dts/bcm94708.dts | 4 ----
> arch/arm/boot/dts/bcm94709.dts | 4 ----
> arch/arm/boot/dts/bcm953012er.dts | 4 ----
> arch/arm/boot/dts/bcm953012k.dts | 1 -
> 20 files changed, 10 insertions(+), 61 deletions(-)
>
> diff --git a/arch/arm/boot/dts/bcm4708-buffalo-wzr-1750dhp.dts b/arch/arm/boot/dts/bcm4708-buffalo-wzr-1750dhp.dts
> index 9cb186e..d49afec0 100644
> --- a/arch/arm/boot/dts/bcm4708-buffalo-wzr-1750dhp.dts
> +++ b/arch/arm/boot/dts/bcm4708-buffalo-wzr-1750dhp.dts
> @@ -136,10 +136,6 @@
> };
> };
>
> -&uart0 {
> - status = "okay";
> -};
> -
> &usb2 {
> vcc-gpio = <&chipcommon 9 GPIO_ACTIVE_HIGH>;
> };
> diff --git a/arch/arm/boot/dts/bcm4708-luxul-xap-1510.dts b/arch/arm/boot/dts/bcm4708-luxul-xap-1510.dts
> index 35e6ed6..f591b0f 100644
> --- a/arch/arm/boot/dts/bcm4708-luxul-xap-1510.dts
> +++ b/arch/arm/boot/dts/bcm4708-luxul-xap-1510.dts
> @@ -55,10 +55,6 @@
> };
> };
>
> -&uart0 {
> - status = "okay";
> -};
> -
> &spi_nor {
> status = "okay";
> };
> diff --git a/arch/arm/boot/dts/bcm4708-luxul-xwc-1000.dts b/arch/arm/boot/dts/bcm4708-luxul-xwc-1000.dts
> index 1c7e53d..50d65d8 100644
> --- a/arch/arm/boot/dts/bcm4708-luxul-xwc-1000.dts
> +++ b/arch/arm/boot/dts/bcm4708-luxul-xwc-1000.dts
> @@ -56,10 +56,6 @@
> };
> };
>
> -&uart0 {
> - status = "okay";
> -};
> -
> &spi_nor {
> status = "okay";
> };
> diff --git a/arch/arm/boot/dts/bcm4708-netgear-r6250.dts b/arch/arm/boot/dts/bcm4708-netgear-r6250.dts
> index 8ce39d5..8519548 100644
> --- a/arch/arm/boot/dts/bcm4708-netgear-r6250.dts
> +++ b/arch/arm/boot/dts/bcm4708-netgear-r6250.dts
> @@ -83,10 +83,6 @@
> };
> };
>
> -&uart0 {
> - status = "okay";
> -};
> -
> &usb3 {
> vcc-gpio = <&chipcommon 0 GPIO_ACTIVE_HIGH>;
> };
> diff --git a/arch/arm/boot/dts/bcm4708-smartrg-sr400ac.dts b/arch/arm/boot/dts/bcm4708-smartrg-sr400ac.dts
> index 70f4bb9..74cfcd3 100644
> --- a/arch/arm/boot/dts/bcm4708-smartrg-sr400ac.dts
> +++ b/arch/arm/boot/dts/bcm4708-smartrg-sr400ac.dts
> @@ -119,10 +119,6 @@
> };
> };
>
> -&uart0 {
> - status = "okay";
> -};
> -
> &spi_nor {
> status = "okay";
> };
> diff --git a/arch/arm/boot/dts/bcm4708.dtsi b/arch/arm/boot/dts/bcm4708.dtsi
> index eed4dd1..d0eec09 100644
> --- a/arch/arm/boot/dts/bcm4708.dtsi
> +++ b/arch/arm/boot/dts/bcm4708.dtsi
> @@ -34,3 +34,7 @@
> };
>
> };
> +
> +&uart0 {
> + status = "okay";
> +};
> diff --git a/arch/arm/boot/dts/bcm47081-buffalo-wzr-600dhp2.dts b/arch/arm/boot/dts/bcm47081-buffalo-wzr-600dhp2.dts
> index a9c8def..2922536 100644
> --- a/arch/arm/boot/dts/bcm47081-buffalo-wzr-600dhp2.dts
> +++ b/arch/arm/boot/dts/bcm47081-buffalo-wzr-600dhp2.dts
> @@ -122,7 +122,3 @@
> };
> };
> };
> -
> -&uart0 {
> - status = "okay";
> -};
> diff --git a/arch/arm/boot/dts/bcm47081.dtsi b/arch/arm/boot/dts/bcm47081.dtsi
> index f720012..c5f7619 100644
> --- a/arch/arm/boot/dts/bcm47081.dtsi
> +++ b/arch/arm/boot/dts/bcm47081.dtsi
> @@ -24,3 +24,7 @@
> };
> };
> };
> +
> +&uart0 {
> + status = "okay";
> +};
> diff --git a/arch/arm/boot/dts/bcm4709-netgear-r7000.dts b/arch/arm/boot/dts/bcm4709-netgear-r7000.dts
> index fd38d2a..0225d82 100644
> --- a/arch/arm/boot/dts/bcm4709-netgear-r7000.dts
> +++ b/arch/arm/boot/dts/bcm4709-netgear-r7000.dts
> @@ -100,7 +100,3 @@
> };
> };
> };
> -
> -&uart0 {
> - status = "okay";
> -};
> diff --git a/arch/arm/boot/dts/bcm4709-netgear-r8000.dts b/arch/arm/boot/dts/bcm4709-netgear-r8000.dts
> index 92f8a72..56d38a3 100644
> --- a/arch/arm/boot/dts/bcm4709-netgear-r8000.dts
> +++ b/arch/arm/boot/dts/bcm4709-netgear-r8000.dts
> @@ -107,10 +107,6 @@
> };
> };
>
> -&uart0 {
> - status = "okay";
> -};
> -
> &usb2 {
> vcc-gpio = <&chipcommon 0 GPIO_ACTIVE_HIGH>;
> };
> diff --git a/arch/arm/boot/dts/bcm4709-tplink-archer-c9-v1.dts b/arch/arm/boot/dts/bcm4709-tplink-archer-c9-v1.dts
> index 9a92c24..c67bfaa 100644
> --- a/arch/arm/boot/dts/bcm4709-tplink-archer-c9-v1.dts
> +++ b/arch/arm/boot/dts/bcm4709-tplink-archer-c9-v1.dts
> @@ -97,10 +97,6 @@
> };
> };
>
> -&uart0 {
> - status = "okay";
> -};
> -
> &usb2 {
> vcc-gpio = <&chipcommon 13 GPIO_ACTIVE_HIGH>;
> };
> diff --git a/arch/arm/boot/dts/bcm4709.dtsi b/arch/arm/boot/dts/bcm4709.dtsi
> index f039765..c645fea 100644
> --- a/arch/arm/boot/dts/bcm4709.dtsi
> +++ b/arch/arm/boot/dts/bcm4709.dtsi
> @@ -8,4 +8,5 @@
>
> &uart0 {
> clock-frequency = <125000000>;
> + status = "okay";
> };
> diff --git a/arch/arm/boot/dts/bcm47094-dlink-dir-885l.dts b/arch/arm/boot/dts/bcm47094-dlink-dir-885l.dts
> index 661348d..7fb9270 100644
> --- a/arch/arm/boot/dts/bcm47094-dlink-dir-885l.dts
> +++ b/arch/arm/boot/dts/bcm47094-dlink-dir-885l.dts
> @@ -105,10 +105,6 @@
> };
> };
>
> -&uart0 {
> - status = "okay";
> -};
> -
> &usb3 {
> vcc-gpio = <&chipcommon 18 GPIO_ACTIVE_HIGH>;
> };
> diff --git a/arch/arm/boot/dts/bcm47094-luxul-xwr-3100.dts b/arch/arm/boot/dts/bcm47094-luxul-xwr-3100.dts
> index 169b35f..2f4a651 100644
> --- a/arch/arm/boot/dts/bcm47094-luxul-xwr-3100.dts
> +++ b/arch/arm/boot/dts/bcm47094-luxul-xwr-3100.dts
> @@ -98,10 +98,6 @@
> };
> };
>
> -&uart0 {
> - status = "okay";
> -};
> -
> &usb3 {
> vcc-gpio = <&chipcommon 18 GPIO_ACTIVE_HIGH>;
> };
> diff --git a/arch/arm/boot/dts/bcm47094-netgear-r8500.dts b/arch/arm/boot/dts/bcm47094-netgear-r8500.dts
> index 521b415..7ecd57c 100644
> --- a/arch/arm/boot/dts/bcm47094-netgear-r8500.dts
> +++ b/arch/arm/boot/dts/bcm47094-netgear-r8500.dts
> @@ -97,7 +97,3 @@
> };
> };
> };
> -
> -&uart0 {
> - status = "okay";
> -};
> diff --git a/arch/arm/boot/dts/bcm47094.dtsi b/arch/arm/boot/dts/bcm47094.dtsi
> index 4f09aa0..4840a78 100644
> --- a/arch/arm/boot/dts/bcm47094.dtsi
> +++ b/arch/arm/boot/dts/bcm47094.dtsi
> @@ -14,4 +14,5 @@
>
> &uart0 {
> clock-frequency = <125000000>;
> + status = "okay";
> };
> diff --git a/arch/arm/boot/dts/bcm94708.dts b/arch/arm/boot/dts/bcm94708.dts
> index 251a486..42855a7 100644
> --- a/arch/arm/boot/dts/bcm94708.dts
> +++ b/arch/arm/boot/dts/bcm94708.dts
> @@ -50,7 +50,3 @@
> reg = <0x00000000 0x08000000>;
> };
> };
> -
> -&uart0 {
> - status = "okay";
> -};
> diff --git a/arch/arm/boot/dts/bcm94709.dts b/arch/arm/boot/dts/bcm94709.dts
> index b16cac9..95e8be6 100644
> --- a/arch/arm/boot/dts/bcm94709.dts
> +++ b/arch/arm/boot/dts/bcm94709.dts
> @@ -50,7 +50,3 @@
> reg = <0x00000000 0x08000000>;
> };
> };
> -
> -&uart0 {
> - status = "okay";
> -};
> diff --git a/arch/arm/boot/dts/bcm953012er.dts b/arch/arm/boot/dts/bcm953012er.dts
> index 0a9abec..decd86b 100644
> --- a/arch/arm/boot/dts/bcm953012er.dts
> +++ b/arch/arm/boot/dts/bcm953012er.dts
> @@ -70,10 +70,6 @@
> };
> };
>
> -&uart0 {
> - status = "okay";
> -};
> -
> &spi_nor {
> status = "okay";
> };
> diff --git a/arch/arm/boot/dts/bcm953012k.dts b/arch/arm/boot/dts/bcm953012k.dts
> index 05a985a..bfd9230 100644
> --- a/arch/arm/boot/dts/bcm953012k.dts
> +++ b/arch/arm/boot/dts/bcm953012k.dts
> @@ -54,7 +54,6 @@
>
> &uart0 {
> clock-frequency = <62499840>;
> - status = "okay";
> };
>
> &uart1 {
>
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [PATCH v2 2/3] crypto: brcm: Add Broadcom SPU driver
From: Raveendra Padasalagi @ 2016-12-04 17:56 UTC (permalink / raw)
To: Rob Rice
Cc: Herbert Xu, David S. Miller, Rob Herring, Mark Rutland,
linux-crypto, devicetree, linux-kernel, Ray Jui, Scott Branden,
Jon Mason, bcm-kernel-feedback-list, Catalin Marinas, Will Deacon,
linux-arm-kernel, Steve Lin
In-Reply-To: <1480714499-1476-3-git-send-email-rob.rice@broadcom.com>
Hi Rob,
For all HMAC implementation of hash algorithms, I could see driver
computes inner and outer hash using software implementation of hash
but Kconfig is missing selection of these algorithms by default, due to
which driver fails to allocate the algorithms.
So please select by default in Kconfig all the supported hash algorithms.
-Raveendra
On Sat, Dec 3, 2016 at 3:04 AM, Rob Rice <rob.rice@broadcom.com> wrote:
> Add Broadcom Secure Processing Unit (SPU) crypto driver for SPU
> hardware crypto offload. The driver supports ablkcipher, ahash,
> and aead symmetric crypto operations.
>
> Signed-off-by: Steve Lin <steven.lin1@broadcom.com>
> Signed-off-by: Rob Rice <rob.rice@broadcom.com>
> ---
> drivers/crypto/Kconfig | 11 +
> drivers/crypto/Makefile | 1 +
> drivers/crypto/bcm/Makefile | 15 +
> drivers/crypto/bcm/cipher.c | 4943 +++++++++++++++++++++++++++++++++++++++++++
> drivers/crypto/bcm/cipher.h | 472 +++++
> drivers/crypto/bcm/spu.c | 1252 +++++++++++
> drivers/crypto/bcm/spu.h | 288 +++
> drivers/crypto/bcm/spu2.c | 1402 ++++++++++++
> drivers/crypto/bcm/spu2.h | 228 ++
> drivers/crypto/bcm/spum.h | 174 ++
> drivers/crypto/bcm/util.c | 584 +++++
> drivers/crypto/bcm/util.h | 117 +
> 12 files changed, 9487 insertions(+)
> create mode 100644 drivers/crypto/bcm/Makefile
> create mode 100644 drivers/crypto/bcm/cipher.c
> create mode 100644 drivers/crypto/bcm/cipher.h
> create mode 100644 drivers/crypto/bcm/spu.c
> create mode 100644 drivers/crypto/bcm/spu.h
> create mode 100644 drivers/crypto/bcm/spu2.c
> create mode 100644 drivers/crypto/bcm/spu2.h
> create mode 100644 drivers/crypto/bcm/spum.h
> create mode 100644 drivers/crypto/bcm/util.c
> create mode 100644 drivers/crypto/bcm/util.h
>
> diff --git a/drivers/crypto/Kconfig b/drivers/crypto/Kconfig
> index 4d2b81f..dd870ec 100644
> --- a/drivers/crypto/Kconfig
> +++ b/drivers/crypto/Kconfig
> @@ -555,4 +555,15 @@ config CRYPTO_DEV_ROCKCHIP
>
> source "drivers/crypto/chelsio/Kconfig"
>
> +config CRYPTO_DEV_BCM_SPU
> + tristate "Broadcom symmetric crypto/hash acceleration support"
> + depends on ARCH_BCM_IPROC
> + depends on BCM_PDC_MBOX
> + default m
> + select CRYPTO_DES
Add "select MD5", "select SHA1" etc for all of the algorithms which
driver is allocating/using software implementation.
> + help
> + This driver provides support for Broadcom crypto acceleration using the
> + Secure Processing Unit (SPU). The SPU driver registers ablkcipher,
> + ahash, and aead algorithms with the kernel cryptographic API.
> +
> endif # CRYPTO_HW
> diff --git a/drivers/crypto/Makefile b/drivers/crypto/Makefile
> index ad7250f..2702650 100644
> --- a/drivers/crypto/Makefile
> +++ b/drivers/crypto/Makefile
> @@ -32,3 +32,4 @@ obj-$(CONFIG_CRYPTO_DEV_VMX) += vmx/
> obj-$(CONFIG_CRYPTO_DEV_SUN4I_SS) += sunxi-ss/
> obj-$(CONFIG_CRYPTO_DEV_ROCKCHIP) += rockchip/
> obj-$(CONFIG_CRYPTO_DEV_CHELSIO) += chelsio/
> +obj-$(CONFIG_CRYPTO_DEV_BCM_SPU) += bcm/
> diff --git a/drivers/crypto/bcm/Makefile b/drivers/crypto/bcm/Makefile
> new file mode 100644
> index 0000000..13cb80e
> --- /dev/null
> +++ b/drivers/crypto/bcm/Makefile
> @@ -0,0 +1,15 @@
> +# File: drivers/crypto/bcm/Makefile
> +#
> +# Makefile for crypto acceleration files for Broadcom SPU driver
> +#
> +# Uncomment to enable debug tracing in the SPU driver.
> +# CFLAGS_util.o := -DDEBUG
> +# CFLAGS_cipher.o := -DDEBUG
> +# CFLAGS_spu.o := -DDEBUG
> +# CFLAGS_spu2.o := -DDEBUG
> +
> +obj-$(CONFIG_CRYPTO_DEV_BCM_SPU) := bcm_crypto_spu.o
> +
> +bcm_crypto_spu-objs := util.o spu.o spu2.o cipher.o
> +
> +ccflags-y += -I. -DBCMDRIVER
> diff --git a/drivers/crypto/bcm/cipher.c b/drivers/crypto/bcm/cipher.c
> new file mode 100644
> index 0000000..f6bbb06
> --- /dev/null
> +++ b/drivers/crypto/bcm/cipher.c
> @@ -0,0 +1,4943 @@
> +/*
> + * Copyright 2016 Broadcom
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License, version 2, as
> + * published by the Free Software Foundation (the "GPL").
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * General Public License version 2 (GPLv2) for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * version 2 (GPLv2) along with this source code.
> + */
> +
> +#include <linux/err.h>
> +#include <linux/module.h>
> +#include <linux/init.h>
> +#include <linux/errno.h>
> +#include <linux/kernel.h>
> +#include <linux/interrupt.h>
> +#include <linux/platform_device.h>
> +#include <linux/scatterlist.h>
> +#include <linux/crypto.h>
> +#include <linux/kthread.h>
> +#include <linux/rtnetlink.h>
> +#include <linux/sched.h>
> +#include <linux/of_address.h>
> +#include <linux/of_device.h>
> +#include <linux/io.h>
> +#include <linux/bitops.h>
> +
> +#include <crypto/algapi.h>
> +#include <crypto/aead.h>
> +#include <crypto/internal/aead.h>
> +#include <crypto/aes.h>
> +#include <crypto/des.h>
> +#include <crypto/sha.h>
> +#include <crypto/md5.h>
> +#include <crypto/authenc.h>
> +#include <crypto/skcipher.h>
> +#include <crypto/hash.h>
> +#include <crypto/aes.h>
> +#include <crypto/sha3.h>
> +
> +#include "util.h"
> +#include "cipher.h"
> +#include "spu.h"
> +#include "spum.h"
> +#include "spu2.h"
> +
> +/* ================= Device Structure ================== */
> +
> +struct device_private iproc_priv;
> +
> +/* ==================== Parameters ===================== */
> +
> +int flow_debug_logging;
> +int packet_debug_logging;
> +int debug_logging_sleep;
> +
> +module_param(flow_debug_logging, int, 0644);
> +MODULE_PARM_DESC(flow_debug_logging, "Enable Flow Debug Logging");
> +
> +module_param(packet_debug_logging, int, 0644);
> +MODULE_PARM_DESC(packet_debug_logging, "Enable Packet Debug Logging");
> +
> +module_param(debug_logging_sleep, int, 0644);
> +MODULE_PARM_DESC(debug_logging_sleep, "Packet Debug Logging Sleep");
> +
> +/*
> + * The value of these module parameters is used to set the priority for each
> + * algo type when this driver registers algos with the kernel crypto API.
> + * To use a priority other than the default, set the priority in the insmod or
> + * modprobe. Changing the module priority after init time has no effect.
> + *
> + * The default priorities are chosen to be lower (less preferred) than ARMv8 CE
> + * algos, but more preferred than generic software algos.
> + */
> +static int cipher_pri = 150;
> +static int hash_pri = 100;
> +static int aead_pri = 150;
> +
> +module_param(cipher_pri, int, 0644);
> +MODULE_PARM_DESC(cipher_pri, "Priority for cipher algos");
> +module_param(hash_pri, int, 0644);
> +MODULE_PARM_DESC(hash_pri, "Priority for hash algos");
> +module_param(aead_pri, int, 0644);
> +MODULE_PARM_DESC(aead_pri, "Priority for AEAD algos");
> +
> +#define MAX_SPUS 16
> +
> +/* A type 3 BCM header, expected to precede the SPU header for SPU-M.
> + * Bits 3 and 4 in the first byte encode the channel number (the dma ringset).
> + * 0x60 - ring 0
> + * 0x68 - ring 1
> + * 0x70 - ring 2
> + * 0x78 - ring 3
> + */
> +char BCMHEADER[] = { 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28 };
> +/*
> + * Some SPU hw does not use BCM header on SPU messages. So BCM_HDR_LEN
> + * is set dynamically after reading SPU type from device tree.
> + */
> +#define BCM_HDR_LEN iproc_priv.bcm_hdr_len
> +
> +/* min and max time to sleep before retrying when mbox queue is full. usec */
> +#define MBOX_SLEEP_MIN 800
> +#define MBOX_SLEEP_MAX 1000
> +
> +static void handle_ablkcipher_resp(struct iproc_reqctx_s *rctx);
> +static void handle_ahash_resp(struct iproc_reqctx_s *rctx);
> +static int ahash_req_done(struct iproc_reqctx_s *rctx);
> +static void handle_aead_resp(struct iproc_reqctx_s *rctx);
> +
> +/**
> + * select_channel() - Select a SPU channel to handle a crypto request. Selects
> + * channel in round robin order.
> + *
> + * Return: channel index
> + */
> +static u8 select_channel(void)
> +{
> + u8 chan_idx = atomic_inc_return(&iproc_priv.next_chan);
> +
> + return chan_idx % iproc_priv.spu.num_chan;
> +}
> +
> +/**
> + * spu_ablkcipher_rx_sg_create() - Build up the scatterlist of buffers used to
> + * receive a SPU response message for an ablkcipher request. Includes buffers to
> + * catch SPU message headers and the response data.
> + * @mssg: mailbox message containing the receive sg
> + * @rctx: crypto request context
> + * @rx_frag_num: number of scatterlist elements required to hold the
> + * SPU response message
> + * @chunksize: Number of bytes of response data expected
> + * @stat_pad_len: Number of bytes required to pad the STAT field to
> + * a 4-byte boundary
> + * Returns:
> + * 0 if successful
> + * < 0 if an error
> + */
> +static int
> +spu_ablkcipher_rx_sg_create(struct brcm_message *mssg,
> + struct iproc_reqctx_s *rctx,
> + u8 rx_frag_num,
> + unsigned int chunksize, u32 stat_pad_len)
> +{
> + struct device *dev = &iproc_priv.pdev->dev;
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct scatterlist *sg; /* used to build sgs in mbox message */
> + struct iproc_ctx_s *ctx = rctx->ctx;
> + u32 datalen; /* Number of bytes of response data expected */
> +
> + mssg->spu.dst = kcalloc(rx_frag_num, sizeof(struct scatterlist),
> + rctx->gfp);
> + if (!mssg->spu.dst)
> + return -ENOMEM;
> +
> + sg = mssg->spu.dst;
> + sg_init_table(sg, rx_frag_num);
> + /* Space for SPU message header */
> + sg_set_buf(sg++, rctx->msg_buf.spu_resp_hdr, ctx->spu_resp_hdr_len);
> +
> + /* If XTS tweak in payload, add buffer to receive encrypted tweak */
> + if ((ctx->cipher.mode == CIPHER_MODE_XTS) &&
> + spu->spu_xts_tweak_in_payload())
> + sg_set_buf(sg++, rctx->msg_buf.c.supdt_tweak,
> + SPU_XTS_TWEAK_SIZE);
> +
> + /* Copy in each dst sg entry from request, up to chunksize */
> + datalen = spu_msg_sg_add(&sg, &rctx->dst_sg, &rctx->dst_skip,
> + rctx->dst_nents, chunksize);
> + if (datalen < chunksize) {
> + dev_err(dev,
> + "%s(): failed to copy dst sg to mbox msg. chunksize %u, datalen %u",
> + __func__, chunksize, datalen);
> + return -EFAULT;
> + }
> +
> + if (ctx->cipher.alg == CIPHER_ALG_RC4)
> + /* Add buffer to catch 260-byte SUPDT field for RC4 */
> + sg_set_buf(sg++, rctx->msg_buf.c.supdt_tweak, SPU_SUPDT_LEN);
> +
> + if (stat_pad_len)
> + sg_set_buf(sg++, rctx->msg_buf.rx_stat_pad, stat_pad_len);
> +
> + memset(rctx->msg_buf.rx_stat, 0, SPU_RX_STATUS_LEN);
> + sg_set_buf(sg, rctx->msg_buf.rx_stat, spu->spu_rx_status_len());
> +
> + return 0;
> +}
> +
> +/**
> + * spu_ablkcipher_tx_sg_create() - Build up the scatterlist of buffers used to
> + * send a SPU request message for an ablkcipher request. Includes SPU message
> + * headers and the request data.
> + * @mssg: mailbox message containing the transmit sg
> + * @rctx: crypto request context
> + * @tx_frag_num: number of scatterlist elements required to construct the
> + * SPU request message
> + * @chunksize: Number of bytes of request data
> + * @pad_len: Number of pad bytes
> + * Returns:
> + * 0 if successful
> + * < 0 if an error
> + */
> +static int
> +spu_ablkcipher_tx_sg_create(struct brcm_message *mssg,
> + struct iproc_reqctx_s *rctx,
> + u8 tx_frag_num, unsigned int chunksize, u32 pad_len)
> +{
> + struct device *dev = &iproc_priv.pdev->dev;
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct scatterlist *sg; /* used to build sgs in mbox message */
> + struct iproc_ctx_s *ctx = rctx->ctx;
> + u32 datalen; /* Number of bytes of response data expected */
> + u32 stat_len;
> +
> + mssg->spu.src = kcalloc(tx_frag_num, sizeof(struct scatterlist),
> + rctx->gfp);
> + if (unlikely(!mssg->spu.src))
> + return -ENOMEM;
> +
> + sg = mssg->spu.src;
> + sg_init_table(sg, tx_frag_num);
> +
> + sg_set_buf(sg++, rctx->msg_buf.bcm_spu_req_hdr,
> + BCM_HDR_LEN + ctx->spu_req_hdr_len);
> +
> + /* if XTS tweak in payload, copy from IV (where crypto API puts it) */
> + if ((ctx->cipher.mode == CIPHER_MODE_XTS) &&
> + spu->spu_xts_tweak_in_payload())
> + sg_set_buf(sg++, rctx->msg_buf.iv_ctr, SPU_XTS_TWEAK_SIZE);
> +
> + /* Copy in each src sg entry from request, up to chunksize */
> + datalen = spu_msg_sg_add(&sg, &rctx->src_sg, &rctx->src_skip,
> + rctx->src_nents, chunksize);
> + if (unlikely(datalen < chunksize)) {
> + dev_err(dev, "%s(): failed to copy src sg to mbox msg",
> + __func__);
> + return -EFAULT;
> + }
> +
> + if (pad_len)
> + sg_set_buf(sg++, rctx->msg_buf.spu_req_pad, pad_len);
> +
> + stat_len = spu->spu_tx_status_len();
> + if (stat_len) {
> + memset(rctx->msg_buf.tx_stat, 0, stat_len);
> + sg_set_buf(sg, rctx->msg_buf.tx_stat, stat_len);
> + }
> + return 0;
> +}
> +
> +/**
> + * handle_ablkcipher_req() - Submit as much of a block cipher request as fits in
> + * a single SPU request message, starting at the current position in the request
> + * data.
> + * @rctx: Crypto request context
> + *
> + * This may be called on the crypto API thread, or, when a request is so large
> + * it must be broken into multiple SPU messages, on the thread used to invoke
> + * the response callback. When requests are broken into multiple SPU
> + * messages, we assume subsequent messages depend on previous results, and
> + * thus always wait for previous results before submitting the next message.
> + * Because requests are submitted in lock step like this, there is no need
> + * to synchronize access to request data structures.
> + *
> + * Return: -EINPROGRESS: request has been accepted and result will be returned
> + * asynchronously
> + * Any other value indicates an error
> + */
> +static int handle_ablkcipher_req(struct iproc_reqctx_s *rctx)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct crypto_async_request *areq = rctx->parent;
> + struct ablkcipher_request *req =
> + container_of(areq, struct ablkcipher_request, base);
> + struct iproc_ctx_s *ctx = rctx->ctx;
> + struct spu_cipher_parms cipher_parms;
> + int err = 0;
> + unsigned int chunksize = 0; /* Num bytes of request to submit */
> + int remaining = 0; /* Bytes of request still to process */
> + int chunk_start; /* Beginning of data for current SPU msg */
> +
> + /* IV or ctr value to use in this SPU msg */
> + u8 local_iv_ctr[MAX_IV_SIZE];
> + u32 stat_pad_len; /* num bytes to align status field */
> + u32 pad_len; /* total length of all padding */
> + bool update_key = false;
> + struct brcm_message *mssg; /* mailbox message */
> + int retry_cnt = 0;
> +
> + /* number of entries in src and dst sg in mailbox message. */
> + u8 rx_frag_num = 2; /* response header and STATUS */
> + u8 tx_frag_num = 1; /* request header */
> +
> + flow_log("%s\n", __func__);
> +
> + cipher_parms.alg = ctx->cipher.alg;
> + cipher_parms.mode = ctx->cipher.mode;
> + cipher_parms.type = ctx->cipher_type;
> + cipher_parms.key_len = ctx->enckeylen;
> + cipher_parms.key_buf = ctx->enckey;
> + cipher_parms.iv_buf = local_iv_ctr;
> + cipher_parms.iv_len = rctx->iv_ctr_len;
> +
> + mssg = &rctx->mb_mssg;
> + chunk_start = rctx->src_sent;
> + remaining = rctx->total_todo - chunk_start;
> +
> + /* determine the chunk we are breaking off and update the indexes */
> + if ((ctx->max_payload != SPU_MAX_PAYLOAD_INF) &&
> + (remaining > ctx->max_payload))
> + chunksize = ctx->max_payload;
> + else
> + chunksize = remaining;
> +
> + rctx->src_sent += chunksize;
> + rctx->total_sent = rctx->src_sent;
> +
> + /* Count number of sg entries to be included in this request */
> + rctx->src_nents = spu_sg_count(rctx->src_sg, rctx->src_skip, chunksize);
> + rctx->dst_nents = spu_sg_count(rctx->dst_sg, rctx->dst_skip, chunksize);
> +
> + if ((ctx->cipher.mode == CIPHER_MODE_CBC) &&
> + rctx->is_encrypt && chunk_start)
> + /*
> + * Encrypting non-first first chunk. Copy last block of
> + * previous result to IV for this chunk.
> + */
> + sg_copy_part_to_buf(req->dst, rctx->msg_buf.iv_ctr,
> + rctx->iv_ctr_len,
> + chunk_start - rctx->iv_ctr_len);
> +
> + if (rctx->iv_ctr_len) {
> + /* get our local copy of the iv */
> + __builtin_memcpy(local_iv_ctr, rctx->msg_buf.iv_ctr,
> + rctx->iv_ctr_len);
> +
> + /* generate the next IV if possible */
> + if ((ctx->cipher.mode == CIPHER_MODE_CBC) &&
> + !rctx->is_encrypt) {
> + /*
> + * CBC Decrypt: next IV is the last ciphertext block in
> + * this chunk
> + */
> + sg_copy_part_to_buf(req->src, rctx->msg_buf.iv_ctr,
> + rctx->iv_ctr_len,
> + rctx->src_sent - rctx->iv_ctr_len);
> + } else if (ctx->cipher.mode == CIPHER_MODE_CTR) {
> + /*
> + * The SPU hardware increments the counter once for
> + * each AES block of 16 bytes. So update the counter
> + * for the next chunk, if there is one. Note that for
> + * this chunk, the counter has already been copied to
> + * local_iv_ctr. We can assume a block size of 16,
> + * because we only support CTR mode for AES, not for
> + * any other cipher alg.
> + */
> + add_to_ctr(rctx->msg_buf.iv_ctr, chunksize >> 4);
> + }
> + }
> +
> + if (ctx->cipher.alg == CIPHER_ALG_RC4) {
> + rx_frag_num++;
> + if (chunk_start) {
> + /*
> + * for non-first RC4 chunks, use SUPDT from previous
> + * response as key for this chunk.
> + */
> + cipher_parms.key_buf = rctx->msg_buf.c.supdt_tweak;
> + update_key = true;
> + cipher_parms.type = CIPHER_TYPE_UPDT;
> + } else if (!rctx->is_encrypt) {
> + /*
> + * First RC4 chunk. For decrypt, key in pre-built msg
> + * header may have been changed if encrypt required
> + * multiple chunks. So revert the key to the
> + * ctx->enckey value.
> + */
> + update_key = true;
> + cipher_parms.type = CIPHER_TYPE_INIT;
> + }
> + }
> +
> + if (ctx->max_payload == SPU_MAX_PAYLOAD_INF)
> + flow_log("max_payload infinite\n");
> + else
> + flow_log("max_payload %u\n", ctx->max_payload);
> +
> + flow_log("sent:%u start:%u remains:%u size:%u\n",
> + rctx->src_sent, chunk_start, remaining, chunksize);
> +
> + /* Copy SPU header template created at setkey time */
> + memcpy(rctx->msg_buf.bcm_spu_req_hdr, ctx->bcm_spu_req_hdr,
> + sizeof(rctx->msg_buf.bcm_spu_req_hdr));
> +
> + /*
> + * Pass SUPDT field as key. Key field in finish() call is only used
> + * when update_key has been set above for RC4. Will be ignored in
> + * all other cases.
> + */
> + spu->spu_cipher_req_finish(rctx->msg_buf.bcm_spu_req_hdr + BCM_HDR_LEN,
> + ctx->spu_req_hdr_len, !(rctx->is_encrypt),
> + &cipher_parms, update_key, chunksize);
> +
> + atomic64_add(chunksize, &iproc_priv.bytes_out);
> +
> + stat_pad_len = spu->spu_wordalign_padlen(chunksize);
> + if (stat_pad_len)
> + rx_frag_num++;
> + pad_len = stat_pad_len;
> + if (pad_len) {
> + tx_frag_num++;
> + spu->spu_request_pad(rctx->msg_buf.spu_req_pad, 0,
> + 0, ctx->auth.alg, ctx->auth.mode,
> + rctx->total_sent, stat_pad_len);
> + }
> +
> + spu->spu_dump_msg_hdr(rctx->msg_buf.bcm_spu_req_hdr + BCM_HDR_LEN,
> + ctx->spu_req_hdr_len);
> + packet_log("payload:\n");
> + dump_sg(rctx->src_sg, rctx->src_skip, chunksize);
> + packet_dump(" pad: ", rctx->msg_buf.spu_req_pad, pad_len);
> +
> + /*
> + * Build mailbox message containing SPU request msg and rx buffers
> + * to catch response message
> + */
> + memset(mssg, 0, sizeof(*mssg));
> + mssg->type = BRCM_MESSAGE_SPU;
> + mssg->ctx = rctx; /* Will be returned in response */
> +
> + /* Create rx scatterlist to catch result */
> + rx_frag_num += rctx->dst_nents;
> +
> + if ((ctx->cipher.mode == CIPHER_MODE_XTS) &&
> + spu->spu_xts_tweak_in_payload())
> + rx_frag_num++; /* extra sg to insert tweak */
> +
> + err = spu_ablkcipher_rx_sg_create(mssg, rctx, rx_frag_num, chunksize,
> + stat_pad_len);
> + if (err)
> + return err;
> +
> + /* Create tx scatterlist containing SPU request message */
> + tx_frag_num += rctx->src_nents;
> + if (spu->spu_tx_status_len())
> + tx_frag_num++;
> +
> + if ((ctx->cipher.mode == CIPHER_MODE_XTS) &&
> + spu->spu_xts_tweak_in_payload())
> + tx_frag_num++; /* extra sg to insert tweak */
> +
> + err = spu_ablkcipher_tx_sg_create(mssg, rctx, tx_frag_num, chunksize,
> + pad_len);
> + if (err)
> + return err;
> +
> + err = mbox_send_message(iproc_priv.mbox[rctx->chan_idx], mssg);
> + if (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) {
> + while ((err == -ENOBUFS) && (retry_cnt < SPU_MB_RETRY_MAX)) {
> + /*
> + * Mailbox queue is full. Since MAY_SLEEP is set, assume
> + * not in atomic context and we can wait and try again.
> + */
> + retry_cnt++;
> + usleep_range(MBOX_SLEEP_MIN, MBOX_SLEEP_MAX);
> + err = mbox_send_message(iproc_priv.mbox[rctx->chan_idx],
> + mssg);
> + atomic_inc(&iproc_priv.mb_no_spc);
> + }
> + }
> + if (unlikely(err < 0)) {
> + atomic_inc(&iproc_priv.mb_send_fail);
> + return err;
> + }
> +
> + return -EINPROGRESS;
> +}
> +
> +/**
> + * handle_ablkcipher_resp() - Process a block cipher SPU response. Updates the
> + * total received count for the request and updates global stats.
> + * @rctx: Crypto request context
> + */
> +static void handle_ablkcipher_resp(struct iproc_reqctx_s *rctx)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> +#ifdef DEBUG
> + struct crypto_async_request *areq = rctx->parent;
> + struct ablkcipher_request *req = ablkcipher_request_cast(areq);
> +#endif
> + struct iproc_ctx_s *ctx = rctx->ctx;
> + u32 payload_len;
> +
> + /* See how much data was returned */
> + payload_len = spu->spu_payload_length(rctx->msg_buf.spu_resp_hdr);
> +
> + /*
> + * In XTS mode, the first SPU_XTS_TWEAK_SIZE bytes may be the
> + * encrypted tweak ("i") value; we don't count those.
> + */
> + if ((ctx->cipher.mode == CIPHER_MODE_XTS) &&
> + spu->spu_xts_tweak_in_payload() &&
> + (payload_len >= SPU_XTS_TWEAK_SIZE))
> + payload_len -= SPU_XTS_TWEAK_SIZE;
> +
> + atomic64_add(payload_len, &iproc_priv.bytes_in);
> +
> + flow_log("%s() offset: %u, bd_len: %u BD:\n",
> + __func__, rctx->total_received, payload_len);
> +
> + dump_sg(req->dst, rctx->total_received, payload_len);
> + if (ctx->cipher.alg == CIPHER_ALG_RC4)
> + packet_dump(" supdt ", rctx->msg_buf.c.supdt_tweak,
> + SPU_SUPDT_LEN);
> +
> + rctx->total_received += payload_len;
> + if (rctx->total_received == rctx->total_todo) {
> + atomic_inc(&iproc_priv.op_counts[SPU_OP_CIPHER]);
> + atomic_inc(
> + &iproc_priv.cipher_cnt[ctx->cipher.alg][ctx->cipher.mode]);
> + }
> +}
> +
> +/**
> + * spu_ahash_rx_sg_create() - Build up the scatterlist of buffers used to
> + * receive a SPU response message for an ahash request.
> + * @mssg: mailbox message containing the receive sg
> + * @rctx: crypto request context
> + * @rx_frag_num: number of scatterlist elements required to hold the
> + * SPU response message
> + * @digestsize: length of hash digest, in bytes
> + * @stat_pad_len: Number of bytes required to pad the STAT field to
> + * a 4-byte boundary
> + * Return:
> + * 0 if successful
> + * < 0 if an error
> + */
> +static int
> +spu_ahash_rx_sg_create(struct brcm_message *mssg,
> + struct iproc_reqctx_s *rctx,
> + u8 rx_frag_num, unsigned int digestsize,
> + u32 stat_pad_len)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct scatterlist *sg; /* used to build sgs in mbox message */
> + struct iproc_ctx_s *ctx = rctx->ctx;
> +
> + mssg->spu.dst = kcalloc(rx_frag_num, sizeof(struct scatterlist),
> + rctx->gfp);
> + if (!mssg->spu.dst)
> + return -ENOMEM;
> +
> + sg = mssg->spu.dst;
> + sg_init_table(sg, rx_frag_num);
> + /* Space for SPU message header */
> + sg_set_buf(sg++, rctx->msg_buf.spu_resp_hdr, ctx->spu_resp_hdr_len);
> +
> + /* Space for digest */
> + sg_set_buf(sg++, rctx->msg_buf.digest, digestsize);
> +
> + if (stat_pad_len)
> + sg_set_buf(sg++, rctx->msg_buf.rx_stat_pad, stat_pad_len);
> +
> + memset(rctx->msg_buf.rx_stat, 0, SPU_RX_STATUS_LEN);
> + sg_set_buf(sg, rctx->msg_buf.rx_stat, spu->spu_rx_status_len());
> + return 0;
> +}
> +
> +/**
> + * spu_ahash_tx_sg_create() - Build up the scatterlist of buffers used to send
> + * a SPU request message for an ahash request. Includes SPU message headers and
> + * the request data.
> + * @mssg: mailbox message containing the transmit sg
> + * @rctx: crypto request context
> + * @tx_frag_num: number of scatterlist elements required to construct the
> + * SPU request message
> + * @spu_hdr_len: length in bytes of SPU message header
> + * @hash_carry_len: Number of bytes of data carried over from previous req
> + * @new_data_len: Number of bytes of new request data
> + * @pad_len: Number of pad bytes
> + * Return:
> + * 0 if successful
> + * < 0 if an error
> + */
> +static int
> +spu_ahash_tx_sg_create(struct brcm_message *mssg,
> + struct iproc_reqctx_s *rctx,
> + u8 tx_frag_num,
> + u32 spu_hdr_len,
> + unsigned int hash_carry_len,
> + unsigned int new_data_len, u32 pad_len)
> +{
> + struct device *dev = &iproc_priv.pdev->dev;
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct scatterlist *sg; /* used to build sgs in mbox message */
> + u32 datalen; /* Number of bytes of response data expected */
> + u32 stat_len;
> +
> + mssg->spu.src = kcalloc(tx_frag_num, sizeof(struct scatterlist),
> + rctx->gfp);
> + if (!mssg->spu.src)
> + return -ENOMEM;
> +
> + sg = mssg->spu.src;
> + sg_init_table(sg, tx_frag_num);
> +
> + sg_set_buf(sg++, rctx->msg_buf.bcm_spu_req_hdr,
> + BCM_HDR_LEN + spu_hdr_len);
> +
> + if (hash_carry_len)
> + sg_set_buf(sg++, rctx->hash_carry, hash_carry_len);
> +
> + if (new_data_len) {
> + /* Copy in each src sg entry from request, up to chunksize */
> + datalen = spu_msg_sg_add(&sg, &rctx->src_sg, &rctx->src_skip,
> + rctx->src_nents, new_data_len);
> + if (datalen < new_data_len) {
> + dev_err(dev,
> + "%s(): failed to copy src sg to mbox msg",
> + __func__);
> + return -EFAULT;
> + }
> + }
> +
> + if (pad_len)
> + sg_set_buf(sg++, rctx->msg_buf.spu_req_pad, pad_len);
> +
> + stat_len = spu->spu_tx_status_len();
> + if (stat_len) {
> + memset(rctx->msg_buf.tx_stat, 0, stat_len);
> + sg_set_buf(sg, rctx->msg_buf.tx_stat, stat_len);
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * handle_ahash_req() - Process an asynchronous hash request from the crypto
> + * API.
> + * @rctx: Crypto request context
> + *
> + * Builds a SPU request message embedded in a mailbox message and submits the
> + * mailbox message on a selected mailbox channel. The SPU request message is
> + * constructed as a scatterlist, including entries from the crypto API's
> + * src scatterlist to avoid copying the data to be hashed. This function is
> + * called either on the thread from the crypto API, or, in the case that the
> + * crypto API request is too large to fit in a single SPU request message,
> + * on the thread that invokes the receive callback with a response message.
> + * Because some operations require the response from one chunk before the next
> + * chunk can be submitted, we always wait for the response for the previous
> + * chunk before submitting the next chunk. Because requests are submitted in
> + * lock step like this, there is no need to synchronize access to request data
> + * structures.
> + *
> + * Return:
> + * -EINPROGRESS: request has been submitted to SPU and response will be
> + * returned asynchronously
> + * -EAGAIN: non-final request included a small amount of data, which for
> + * efficiency we did not submit to the SPU, but instead stored
> + * to be submitted to the SPU with the next part of the request
> + * other: an error code
> + */
> +static int handle_ahash_req(struct iproc_reqctx_s *rctx)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct crypto_async_request *areq = rctx->parent;
> + struct ahash_request *req = ahash_request_cast(areq);
> + struct crypto_ahash *ahash = crypto_ahash_reqtfm(req);
> + struct crypto_tfm *tfm = crypto_ahash_tfm(ahash);
> + unsigned int blocksize = crypto_tfm_alg_blocksize(tfm);
> + struct iproc_ctx_s *ctx = rctx->ctx;
> +
> + /* number of bytes still to be hashed in this req */
> + unsigned int nbytes_to_hash = 0;
> + int err = 0;
> + unsigned int chunksize = 0; /* length of hash carry + new data */
> + /*
> + * length of new data, not from hash carry, to be submitted in
> + * this hw request
> + */
> + unsigned int new_data_len;
> +
> + unsigned int chunk_start = 0;
> + u32 db_size; /* Length of data field, incl gcm and hash padding */
> + int pad_len = 0; /* total pad len, including gcm, hash, stat padding */
> + u32 data_pad_len = 0; /* length of GCM/CCM padding */
> + u32 stat_pad_len = 0; /* length of padding to align STATUS word */
> + struct brcm_message *mssg; /* mailbox message */
> + struct spu_request_opts req_opts;
> + struct spu_cipher_parms cipher_parms;
> + struct spu_hash_parms hash_parms;
> + struct spu_aead_parms aead_parms;
> + unsigned int local_nbuf;
> + u32 spu_hdr_len;
> + unsigned int digestsize;
> + u16 rem = 0;
> + int retry_cnt = 0;
> +
> + /*
> + * number of entries in src and dst sg. Always includes SPU msg header.
> + * rx always includes a buffer to catch digest and STATUS.
> + */
> + u8 rx_frag_num = 3;
> + u8 tx_frag_num = 1;
> +
> + flow_log("total_todo %u, total_sent %u\n",
> + rctx->total_todo, rctx->total_sent);
> +
> + memset(&req_opts, 0, sizeof(req_opts));
> + memset(&cipher_parms, 0, sizeof(cipher_parms));
> + memset(&hash_parms, 0, sizeof(hash_parms));
> + memset(&aead_parms, 0, sizeof(aead_parms));
> +
> + req_opts.bd_suppress = true;
> + hash_parms.alg = ctx->auth.alg;
> + hash_parms.mode = ctx->auth.mode;
> + hash_parms.type = HASH_TYPE_NONE;
> + hash_parms.key_buf = (u8 *)ctx->authkey;
> + hash_parms.key_len = ctx->authkeylen;
> +
> + /*
> + * For hash algorithms below assignment looks bit odd but
> + * it's needed for AES-XCBC and AES-CMAC hash algorithms
> + * to differentiate between 128, 192, 256 bit key values.
> + * Based on the key values, hash algorithm is selected.
> + * For example for 128 bit key, hash algorithm is AES-128.
> + */
> + cipher_parms.type = ctx->cipher_type;
> +
> + mssg = &rctx->mb_mssg;
> + chunk_start = rctx->src_sent;
> +
> + /*
> + * Compute the amount remaining to hash. This may include data
> + * carried over from previous requests.
> + */
> + nbytes_to_hash = rctx->total_todo - rctx->total_sent;
> + chunksize = nbytes_to_hash;
> + if ((ctx->max_payload != SPU_MAX_PAYLOAD_INF) &&
> + (chunksize > ctx->max_payload))
> + chunksize = ctx->max_payload;
> +
> + /*
> + * If this is not a final request and the request data is not a multiple
> + * of a full block, then simply park the extra data and prefix it to the
> + * data for the next request.
> + */
> + if (!rctx->is_final) {
> + u8 *dest = rctx->hash_carry + rctx->hash_carry_len;
> + u16 new_len; /* len of data to add to hash carry */
> +
> + rem = chunksize % blocksize; /* remainder */
> + if (rem) {
> + /* chunksize not a multiple of blocksize */
> + chunksize -= rem;
> + if (chunksize == 0) {
> + /* Don't have a full block to submit to hw */
> + new_len = rem - rctx->hash_carry_len;
> + sg_copy_part_to_buf(req->src, dest, new_len,
> + rctx->src_sent);
> + rctx->hash_carry_len = rem;
> + flow_log("Exiting with hash carry len: %u\n",
> + rctx->hash_carry_len);
> + packet_dump(" buf: ",
> + rctx->hash_carry,
> + rctx->hash_carry_len);
> + return -EAGAIN;
> + }
> + }
> + }
> +
> + /* if we have hash carry, then prefix it to the data in this request */
> + local_nbuf = rctx->hash_carry_len;
> + rctx->hash_carry_len = 0;
> + if (local_nbuf)
> + tx_frag_num++;
> + new_data_len = chunksize - local_nbuf;
> +
> + /* Count number of sg entries to be used in this request */
> + rctx->src_nents = spu_sg_count(rctx->src_sg, rctx->src_skip,
> + new_data_len);
> +
> + /* AES hashing keeps key size in type field, so need to copy it here */
> + if (hash_parms.alg == HASH_ALG_AES)
> + hash_parms.type = cipher_parms.type;
> + else
> + hash_parms.type = spu->spu_hash_type(rctx->total_sent);
> +
> + digestsize = spu->spu_digest_size(ctx->digestsize, ctx->auth.alg,
> + hash_parms.type);
> + hash_parms.digestsize = digestsize;
> +
> + /* update the indexes */
> + rctx->total_sent += chunksize;
> + /* if you sent a prebuf then that wasn't from this req->src */
> + rctx->src_sent += new_data_len;
> +
> + if ((rctx->total_sent == rctx->total_todo) && rctx->is_final)
> + hash_parms.pad_len = spu->spu_hash_pad_len(hash_parms.alg,
> + hash_parms.mode,
> + chunksize,
> + blocksize);
> +
> + /*
> + * If a non-first chunk, then include the digest returned from the
> + * previous chunk so that hw can add to it (except for AES types).
> + */
> + if ((hash_parms.type == HASH_TYPE_UPDT) &&
> + (hash_parms.alg != HASH_ALG_AES)) {
> + hash_parms.key_buf = rctx->incr_hash;
> + hash_parms.key_len = digestsize;
> + }
> +
> + atomic64_add(chunksize, &iproc_priv.bytes_out);
> +
> + flow_log("%s() final: %u nbuf: %u ",
> + __func__, rctx->is_final, local_nbuf);
> +
> + if (ctx->max_payload == SPU_MAX_PAYLOAD_INF)
> + flow_log("max_payload infinite\n");
> + else
> + flow_log("max_payload %u\n", ctx->max_payload);
> +
> + flow_log("chunk_start: %u chunk_size: %u\n", chunk_start, chunksize);
> +
> + /* Prepend SPU header with type 3 BCM header */
> + memcpy(rctx->msg_buf.bcm_spu_req_hdr, BCMHEADER, BCM_HDR_LEN);
> +
> + hash_parms.prebuf_len = local_nbuf;
> + spu_hdr_len = spu->spu_create_request(rctx->msg_buf.bcm_spu_req_hdr +
> + BCM_HDR_LEN,
> + &req_opts, &cipher_parms,
> + &hash_parms, &aead_parms,
> + new_data_len);
> +
> + if (spu_hdr_len == 0) {
> + pr_err("Failed to create SPU request header\n");
> + return -EFAULT;
> + }
> +
> + /*
> + * Determine total length of padding required. Put all padding in one
> + * buffer.
> + */
> + data_pad_len = spu->spu_gcm_ccm_pad_len(ctx->cipher.mode, chunksize);
> + db_size = spu_real_db_size(0, 0, local_nbuf, new_data_len,
> + 0, 0, hash_parms.pad_len);
> + if (spu->spu_tx_status_len())
> + stat_pad_len = spu->spu_wordalign_padlen(db_size);
> + if (stat_pad_len)
> + rx_frag_num++;
> + pad_len = hash_parms.pad_len + data_pad_len + stat_pad_len;
> + if (pad_len) {
> + tx_frag_num++;
> + spu->spu_request_pad(rctx->msg_buf.spu_req_pad, data_pad_len,
> + hash_parms.pad_len, ctx->auth.alg,
> + ctx->auth.mode, rctx->total_sent,
> + stat_pad_len);
> + }
> +
> + spu->spu_dump_msg_hdr(rctx->msg_buf.bcm_spu_req_hdr + BCM_HDR_LEN,
> + spu_hdr_len);
> + packet_dump(" prebuf: ", rctx->hash_carry, local_nbuf);
> + flow_log("Data:\n");
> + dump_sg(rctx->src_sg, rctx->src_skip, new_data_len);
> + packet_dump(" pad: ", rctx->msg_buf.spu_req_pad, pad_len);
> +
> + /*
> + * Build mailbox message containing SPU request msg and rx buffers
> + * to catch response message
> + */
> + memset(mssg, 0, sizeof(*mssg));
> + mssg->type = BRCM_MESSAGE_SPU;
> + mssg->ctx = rctx; /* Will be returned in response */
> +
> + /* Create rx scatterlist to catch result */
> + err = spu_ahash_rx_sg_create(mssg, rctx, rx_frag_num, digestsize,
> + stat_pad_len);
> + if (err)
> + return err;
> +
> + /* Create tx scatterlist containing SPU request message */
> + tx_frag_num += rctx->src_nents;
> + if (spu->spu_tx_status_len())
> + tx_frag_num++;
> + err = spu_ahash_tx_sg_create(mssg, rctx, tx_frag_num, spu_hdr_len,
> + local_nbuf, new_data_len, pad_len);
> + if (err)
> + return err;
> +
> + err = mbox_send_message(iproc_priv.mbox[rctx->chan_idx], mssg);
> + if (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) {
> + while ((err == -ENOBUFS) && (retry_cnt < SPU_MB_RETRY_MAX)) {
> + /*
> + * Mailbox queue is full. Since MAY_SLEEP is set, assume
> + * not in atomic context and we can wait and try again.
> + */
> + retry_cnt++;
> + usleep_range(MBOX_SLEEP_MIN, MBOX_SLEEP_MAX);
> + err = mbox_send_message(iproc_priv.mbox[rctx->chan_idx],
> + mssg);
> + atomic_inc(&iproc_priv.mb_no_spc);
> + }
> + }
> + if (err < 0) {
> + atomic_inc(&iproc_priv.mb_send_fail);
> + return err;
> + }
> + return -EINPROGRESS;
> +}
> +
> +/**
> + * handle_ahash_resp() - Process a SPU response message for a hash request.
> + * Checks if the entire crypto API request has been processed, and if so,
> + * invokes post processing on the result.
> + * @rctx: Crypto request context
> + */
> +static void handle_ahash_resp(struct iproc_reqctx_s *rctx)
> +{
> + struct iproc_ctx_s *ctx = rctx->ctx;
> +#ifdef DEBUG
> + struct crypto_async_request *areq = rctx->parent;
> + struct ahash_request *req = ahash_request_cast(areq);
> + struct crypto_ahash *ahash = crypto_ahash_reqtfm(req);
> + unsigned int blocksize =
> + crypto_tfm_alg_blocksize(crypto_ahash_tfm(ahash));
> +#endif
> + /*
> + * Save hash to use as input to next op if incremental. Might be copying
> + * too much, but that's easier than figuring out actual digest size here
> + */
> + memcpy(rctx->incr_hash, rctx->msg_buf.digest, MAX_DIGEST_SIZE);
> +
> + flow_log("%s() blocksize:%u digestsize:%u\n",
> + __func__, blocksize, ctx->digestsize);
> +
> + atomic64_add(ctx->digestsize, &iproc_priv.bytes_in);
> +
> + if (rctx->is_final && (rctx->total_sent == rctx->total_todo))
> + ahash_req_done(rctx);
> +}
> +
> +/**
> + * spu_hmac_outer_hash() - Request synchonous software compute of the outer hash
> + * for an HMAC request.
> + * @req: The HMAC request from the crypto API
> + * @ctx: The session context
> + *
> + * Return: 0 if synchronous hash operation successful
> + * -EINVAL if the hash algo is unrecognized
> + * any other value indicates an error
> + */
> +static int spu_hmac_outer_hash(struct ahash_request *req,
> + struct iproc_ctx_s *ctx)
> +{
> + struct crypto_ahash *ahash = crypto_ahash_reqtfm(req);
> + unsigned int blocksize =
> + crypto_tfm_alg_blocksize(crypto_ahash_tfm(ahash));
> + int rc;
> +
> + switch (ctx->auth.alg) {
> + case HASH_ALG_MD5:
> + rc = do_shash("md5", req->result, ctx->opad, blocksize,
> + req->result, ctx->digestsize, NULL, 0);
> + break;
> + case HASH_ALG_SHA1:
> + rc = do_shash("sha1", req->result, ctx->opad, blocksize,
> + req->result, ctx->digestsize, NULL, 0);
> + break;
> + case HASH_ALG_SHA224:
> + rc = do_shash("sha224", req->result, ctx->opad, blocksize,
> + req->result, ctx->digestsize, NULL, 0);
> + break;
> + case HASH_ALG_SHA256:
> + rc = do_shash("sha256", req->result, ctx->opad, blocksize,
> + req->result, ctx->digestsize, NULL, 0);
> + break;
> + case HASH_ALG_SHA384:
> + rc = do_shash("sha384", req->result, ctx->opad, blocksize,
> + req->result, ctx->digestsize, NULL, 0);
> + break;
> + case HASH_ALG_SHA512:
> + rc = do_shash("sha512", req->result, ctx->opad, blocksize,
> + req->result, ctx->digestsize, NULL, 0);
> + break;
> + default:
> + pr_err("%s() Error : unknown hmac type\n", __func__);
> + rc = -EINVAL;
> + }
> + return rc;
> +}
> +
> +/**
> + * ahash_req_done() - Process a hash result from the SPU hardware.
> + * @rctx: Crypto request context
> + *
> + * Return: 0 if successful
> + * < 0 if an error
> + */
> +static int ahash_req_done(struct iproc_reqctx_s *rctx)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct crypto_async_request *areq = rctx->parent;
> + struct ahash_request *req = ahash_request_cast(areq);
> + struct iproc_ctx_s *ctx = rctx->ctx;
> + int err;
> +
> + memcpy(req->result, rctx->msg_buf.digest, ctx->digestsize);
> +
> + if (spu->spu_type == SPU_TYPE_SPUM) {
> + /* byte swap the output from the UPDT function to network byte
> + * order
> + */
> + if (ctx->auth.alg == HASH_ALG_MD5) {
> + __swab32s((u32 *)req->result);
> + __swab32s(((u32 *)req->result) + 1);
> + __swab32s(((u32 *)req->result) + 2);
> + __swab32s(((u32 *)req->result) + 3);
> + __swab32s(((u32 *)req->result) + 4);
> + }
> + }
> +
> + flow_dump(" digest ", req->result, ctx->digestsize);
> +
> + /* if this an HMAC then do the outer hash */
> + if (rctx->is_sw_hmac) {
> + err = spu_hmac_outer_hash(req, ctx);
> + if (err < 0)
> + return err;
> + flow_dump(" hmac: ", req->result, ctx->digestsize);
> + }
> +
> + if (rctx->is_sw_hmac || ctx->auth.mode == HASH_MODE_HMAC) {
> + atomic_inc(&iproc_priv.op_counts[SPU_OP_HMAC]);
> + atomic_inc(&iproc_priv.hmac_cnt[ctx->auth.alg]);
> + } else {
> + atomic_inc(&iproc_priv.op_counts[SPU_OP_HASH]);
> + atomic_inc(&iproc_priv.hash_cnt[ctx->auth.alg]);
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * spu_aead_rx_sg_create() - Build up the scatterlist of buffers used to receive
> + * a SPU response message for an AEAD request. Includes buffers to catch SPU
> + * message headers and the response data.
> + * @mssg: mailbox message containing the receive sg
> + * @rctx: crypto request context
> + * @rx_frag_num: number of scatterlist elements required to hold the
> + * SPU response message
> + * @assoc_len: Length of associated data included in the crypto request
> + * @ret_iv_len: Length of IV returned in response
> + * @resp_len: Number of bytes of response data expected to be written to
> + * dst buffer from crypto API
> + * @digestsize: Length of hash digest, in bytes
> + * @stat_pad_len: Number of bytes required to pad the STAT field to
> + * a 4-byte boundary
> + * Returns:
> + * 0 if successful
> + * < 0 if an error
> + */
> +static int spu_aead_rx_sg_create(struct brcm_message *mssg,
> + struct aead_request *req,
> + struct iproc_reqctx_s *rctx,
> + u8 rx_frag_num,
> + unsigned int assoc_len,
> + u32 ret_iv_len, unsigned int resp_len,
> + unsigned int digestsize, u32 stat_pad_len)
> +{
> + struct device *dev = &iproc_priv.pdev->dev;
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct scatterlist *sg; /* used to build sgs in mbox message */
> + struct iproc_ctx_s *ctx = rctx->ctx;
> + u32 datalen; /* Number of bytes of response data expected */
> + u32 assoc_buf_len;
> + u8 data_padlen = 0;
> +
> + if (ctx->is_rfc4543) {
> + /* RFC4543: only pad after data, not after AAD */
> + data_padlen = spu->spu_gcm_ccm_pad_len(ctx->cipher.mode,
> + assoc_len + resp_len);
> + assoc_buf_len = assoc_len;
> + } else {
> + data_padlen = spu->spu_gcm_ccm_pad_len(ctx->cipher.mode,
> + resp_len);
> + assoc_buf_len = spu->spu_assoc_resp_len(ctx->cipher.mode,
> + assoc_len, ret_iv_len,
> + rctx->is_encrypt);
> + }
> +
> + if (ctx->cipher.mode == CIPHER_MODE_CCM)
> + /* ICV (after data) must be in the next 32-bit word for CCM */
> + data_padlen += spu->spu_wordalign_padlen(assoc_buf_len +
> + resp_len +
> + data_padlen);
> +
> + if (data_padlen)
> + /* have to catch gcm pad in separate buffer */
> + rx_frag_num++;
> +
> + mssg->spu.dst = kcalloc(rx_frag_num, sizeof(struct scatterlist),
> + rctx->gfp);
> + if (!mssg->spu.dst)
> + return -ENOMEM;
> +
> + sg = mssg->spu.dst;
> + sg_init_table(sg, rx_frag_num);
> +
> + /* Space for SPU message header */
> + sg_set_buf(sg++, rctx->msg_buf.spu_resp_hdr, ctx->spu_resp_hdr_len);
> +
> + if (assoc_buf_len) {
> + /*
> + * Don't write directly to req->dst, because SPU may pad the
> + * assoc data in the response
> + */
> + memset(rctx->msg_buf.a.resp_aad, 0, assoc_buf_len);
> + sg_set_buf(sg++, rctx->msg_buf.a.resp_aad, assoc_buf_len);
> + }
> +
> + /*
> + * Copy in each dst sg entry from request, up to chunksize.
> + * dst sg catches just the data. digest caught in separate buf.
> + */
> + datalen = spu_msg_sg_add(&sg, &rctx->dst_sg, &rctx->dst_skip,
> + rctx->dst_nents, resp_len);
> + if (datalen < (resp_len)) {
> + dev_err(dev,
> + "%s(): failed to copy dst sg to mbox msg. expected len %u, datalen %u",
> + __func__, resp_len, datalen);
> + return -EFAULT;
> + }
> +
> + /* If GCM/CCM data is padded, catch padding in separate buffer */
> + if (data_padlen) {
> + memset(rctx->msg_buf.a.gcmpad, 0, data_padlen);
> + sg_set_buf(sg++, rctx->msg_buf.a.gcmpad, data_padlen);
> + }
> +
> + /* Always catch ICV in separate buffer */
> + sg_set_buf(sg++, rctx->msg_buf.digest, digestsize);
> +
> + flow_log("stat_pad_len %u\n", stat_pad_len);
> + if (stat_pad_len) {
> + memset(rctx->msg_buf.rx_stat_pad, 0, stat_pad_len);
> + sg_set_buf(sg++, rctx->msg_buf.rx_stat_pad, stat_pad_len);
> + }
> +
> + memset(rctx->msg_buf.rx_stat, 0, SPU_RX_STATUS_LEN);
> + sg_set_buf(sg, rctx->msg_buf.rx_stat, spu->spu_rx_status_len());
> +
> + return 0;
> +}
> +
> +/**
> + * spu_aead_tx_sg_create() - Build up the scatterlist of buffers used to send a
> + * SPU request message for an AEAD request. Includes SPU message headers and the
> + * request data.
> + * @mssg: mailbox message containing the transmit sg
> + * @rctx: crypto request context
> + * @tx_frag_num: number of scatterlist elements required to construct the
> + * SPU request message
> + * @spu_hdr_len: length of SPU message header in bytes
> + * @assoc: crypto API associated data scatterlist
> + * @assoc_len: length of associated data
> + * @assoc_nents: number of scatterlist entries containing assoc data
> + * @aead_iv_len: length of AEAD IV, if included
> + * @chunksize: Number of bytes of request data
> + * @aad_pad_len: Number of bytes of padding at end of AAD. For GCM/CCM.
> + * @pad_len: Number of pad bytes
> + * @incl_icv: If true, write separate ICV buffer after data and
> + * any padding
> + * Return:
> + * 0 if successful
> + * < 0 if an error
> + */
> +static int spu_aead_tx_sg_create(struct brcm_message *mssg,
> + struct iproc_reqctx_s *rctx,
> + u8 tx_frag_num,
> + u32 spu_hdr_len,
> + struct scatterlist *assoc,
> + unsigned int assoc_len,
> + int assoc_nents,
> + unsigned int aead_iv_len,
> + unsigned int chunksize,
> + u32 aad_pad_len, u32 pad_len, bool incl_icv)
> +{
> + struct device *dev = &iproc_priv.pdev->dev;
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct scatterlist *sg; /* used to build sgs in mbox message */
> + struct scatterlist *assoc_sg = assoc;
> + struct iproc_ctx_s *ctx = rctx->ctx;
> + u32 datalen; /* Number of bytes of data to write */
> + u32 written; /* Number of bytes of data written */
> + u32 assoc_offset = 0;
> + u32 stat_len;
> +
> + mssg->spu.src = kcalloc(tx_frag_num, sizeof(struct scatterlist),
> + rctx->gfp);
> + if (!mssg->spu.src)
> + return -ENOMEM;
> +
> + sg = mssg->spu.src;
> + sg_init_table(sg, tx_frag_num);
> +
> + sg_set_buf(sg++, rctx->msg_buf.bcm_spu_req_hdr,
> + BCM_HDR_LEN + spu_hdr_len);
> +
> + if (assoc_len) {
> + /* Copy in each associated data sg entry from request */
> + written = spu_msg_sg_add(&sg, &assoc_sg, &assoc_offset,
> + assoc_nents, assoc_len);
> + if (written < assoc_len) {
> + dev_err(dev,
> + "%s(): failed to copy assoc sg to mbox msg",
> + __func__);
> + return -EFAULT;
> + }
> + }
> +
> + if (aead_iv_len)
> + sg_set_buf(sg++, rctx->msg_buf.iv_ctr, aead_iv_len);
> +
> + if (aad_pad_len) {
> + memset(rctx->msg_buf.a.req_aad_pad, 0, aad_pad_len);
> + sg_set_buf(sg++, rctx->msg_buf.a.req_aad_pad, aad_pad_len);
> + }
> +
> + datalen = chunksize;
> + if ((chunksize > ctx->digestsize) && incl_icv)
> + datalen -= ctx->digestsize;
> + if (datalen) {
> + /* For aead, a single msg should consume the entire src sg */
> + written = spu_msg_sg_add(&sg, &rctx->src_sg, &rctx->src_skip,
> + rctx->src_nents, datalen);
> + if (written < datalen) {
> + dev_err(dev, "%s(): failed to copy src sg to mbox msg",
> + __func__);
> + return -EFAULT;
> + }
> + }
> +
> + if (pad_len) {
> + memset(rctx->msg_buf.spu_req_pad, 0, pad_len);
> + sg_set_buf(sg++, rctx->msg_buf.spu_req_pad, pad_len);
> + }
> +
> + if (incl_icv)
> + sg_set_buf(sg++, rctx->msg_buf.digest, ctx->digestsize);
> +
> + stat_len = spu->spu_tx_status_len();
> + if (stat_len) {
> + memset(rctx->msg_buf.tx_stat, 0, stat_len);
> + sg_set_buf(sg, rctx->msg_buf.tx_stat, stat_len);
> + }
> + return 0;
> +}
> +
> +/**
> + * handle_aead_req() - Submit a SPU request message for the next chunk of the
> + * current AEAD request.
> + * @rctx: Crypto request context
> + *
> + * Unlike other operation types, we assume the length of the request fits in
> + * a single SPU request message. aead_enqueue() makes sure this is true.
> + * Comments for other op types regarding threads applies here as well.
> + *
> + * Unlike incremental hash ops, where the spu returns the entire hash for
> + * truncated algs like sha-224, the SPU returns just the truncated hash in
> + * response to aead requests. So digestsize is always ctx->digestsize here.
> + *
> + * Return: -EINPROGRESS: crypto request has been accepted and result will be
> + * returned asynchronously
> + * Any other value indicates an error
> + */
> +static int handle_aead_req(struct iproc_reqctx_s *rctx)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct crypto_async_request *areq = rctx->parent;
> + struct aead_request *req = container_of(areq,
> + struct aead_request, base);
> + struct iproc_ctx_s *ctx = rctx->ctx;
> + int err;
> + unsigned int chunksize;
> + unsigned int resp_len;
> + u32 spu_hdr_len;
> + u32 db_size;
> + u32 stat_pad_len;
> + u32 pad_len;
> + struct brcm_message *mssg; /* mailbox message */
> + struct spu_request_opts req_opts;
> + struct spu_cipher_parms cipher_parms;
> + struct spu_hash_parms hash_parms;
> + struct spu_aead_parms aead_parms;
> + int assoc_nents = 0;
> + bool incl_icv = false;
> + unsigned int digestsize = ctx->digestsize;
> + int retry_cnt = 0;
> +
> + /* number of entries in src and dst sg. Always includes SPU msg header.
> + */
> + u8 rx_frag_num = 2; /* and STATUS */
> + u8 tx_frag_num = 1;
> +
> + /* doing the whole thing at once */
> + chunksize = rctx->total_todo;
> +
> + flow_log("%s: chunksize %u\n", __func__, chunksize);
> +
> + memset(&req_opts, 0, sizeof(req_opts));
> + memset(&hash_parms, 0, sizeof(hash_parms));
> + memset(&aead_parms, 0, sizeof(aead_parms));
> +
> + req_opts.is_inbound = !(rctx->is_encrypt);
> + req_opts.auth_first = ctx->auth_first;
> + req_opts.is_aead = true;
> + req_opts.is_esp = ctx->is_esp;
> +
> + cipher_parms.alg = ctx->cipher.alg;
> + cipher_parms.mode = ctx->cipher.mode;
> + cipher_parms.type = ctx->cipher_type;
> + cipher_parms.key_buf = ctx->enckey;
> + cipher_parms.key_len = ctx->enckeylen;
> + cipher_parms.iv_buf = rctx->msg_buf.iv_ctr;
> + cipher_parms.iv_len = rctx->iv_ctr_len;
> +
> + hash_parms.alg = ctx->auth.alg;
> + hash_parms.mode = ctx->auth.mode;
> + hash_parms.type = HASH_TYPE_NONE;
> + hash_parms.key_buf = (u8 *)ctx->authkey;
> + hash_parms.key_len = ctx->authkeylen;
> + hash_parms.digestsize = digestsize;
> +
> + if ((ctx->auth.alg == HASH_ALG_SHA224) &&
> + (ctx->authkeylen < SHA224_DIGEST_SIZE))
> + hash_parms.key_len = SHA224_DIGEST_SIZE;
> +
> + aead_parms.assoc_size = req->assoclen;
> + if (ctx->is_esp && !ctx->is_rfc4543) {
> + /*
> + * 8-byte IV is included assoc data in request. SPU2
> + * expects AAD to include just SPI and seqno. So
> + * subtract off the IV len.
> + */
> + aead_parms.assoc_size -= GCM_ESP_IV_SIZE;
> +
> + if (rctx->is_encrypt) {
> + aead_parms.return_iv = true;
> + aead_parms.ret_iv_len = GCM_ESP_IV_SIZE;
> + aead_parms.ret_iv_off = GCM_ESP_SALT_SIZE;
> + }
> + } else {
> + aead_parms.ret_iv_len = 0;
> + }
> +
> + /*
> + * Count number of sg entries from the crypto API request that are to
> + * be included in this mailbox message. For dst sg, don't count space
> + * for digest. Digest gets caught in a separate buffer and copied back
> + * to dst sg when processing response.
> + */
> + rctx->src_nents = spu_sg_count(rctx->src_sg, rctx->src_skip, chunksize);
> + rctx->dst_nents = spu_sg_count(rctx->dst_sg, rctx->dst_skip, chunksize);
> + if (aead_parms.assoc_size)
> + assoc_nents = spu_sg_count(rctx->assoc, 0,
> + aead_parms.assoc_size);
> +
> + mssg = &rctx->mb_mssg;
> +
> + rctx->total_sent = chunksize;
> + rctx->src_sent = chunksize;
> + if (spu->spu_assoc_resp_len(ctx->cipher.mode,
> + aead_parms.assoc_size,
> + aead_parms.ret_iv_len,
> + rctx->is_encrypt))
> + rx_frag_num++;
> +
> + aead_parms.iv_len = spu->spu_aead_ivlen(ctx->cipher.mode,
> + rctx->iv_ctr_len);
> +
> + if (ctx->auth.alg == HASH_ALG_AES)
> + hash_parms.type = ctx->cipher_type;
> +
> + /* General case AAD padding (CCM and RFC4543 special cases below) */
> + aead_parms.aad_pad_len = spu->spu_gcm_ccm_pad_len(ctx->cipher.mode,
> + aead_parms.assoc_size);
> +
> + /* General case data padding (CCM decrypt special case below) */
> + aead_parms.data_pad_len = spu->spu_gcm_ccm_pad_len(ctx->cipher.mode,
> + chunksize);
> +
> + if (ctx->cipher.mode == CIPHER_MODE_CCM) {
> + /*
> + * for CCM, AAD len + 2 (rather than AAD len) needs to be
> + * 128-bit aligned
> + */
> + aead_parms.aad_pad_len = spu->spu_gcm_ccm_pad_len(
> + ctx->cipher.mode,
> + aead_parms.assoc_size + 2);
> +
> + /*
> + * And when decrypting CCM, need to pad without including
> + * size of ICV which is tacked on to end of chunk
> + */
> + if (!rctx->is_encrypt)
> + aead_parms.data_pad_len =
> + spu->spu_gcm_ccm_pad_len(ctx->cipher.mode,
> + chunksize - digestsize);
> +
> + /* CCM also requires software to rewrite portions of IV: */
> + spu->spu_ccm_update_iv(digestsize, &cipher_parms, req->assoclen,
> + chunksize, rctx->is_encrypt,
> + ctx->is_esp);
> + }
> +
> + if (ctx->is_rfc4543) {
> + /*
> + * RFC4543: data is included in AAD, so don't pad after AAD
> + * and pad data based on both AAD + data size
> + */
> + aead_parms.aad_pad_len = 0;
> + if (!rctx->is_encrypt)
> + aead_parms.data_pad_len = spu->spu_gcm_ccm_pad_len(
> + ctx->cipher.mode,
> + aead_parms.assoc_size + chunksize -
> + digestsize);
> + else
> + aead_parms.data_pad_len = spu->spu_gcm_ccm_pad_len(
> + ctx->cipher.mode,
> + aead_parms.assoc_size + chunksize);
> +
> + req_opts.is_rfc4543 = true;
> + }
> +
> + if (spu_req_incl_icv(ctx->cipher.mode, rctx->is_encrypt)) {
> + incl_icv = true;
> + tx_frag_num++;
> + /* Copy ICV from end of src scatterlist to digest buf */
> + sg_copy_part_to_buf(req->src, rctx->msg_buf.digest, digestsize,
> + req->assoclen + rctx->total_sent -
> + digestsize);
> + }
> +
> + atomic64_add(chunksize, &iproc_priv.bytes_out);
> +
> + flow_log("%s()-sent chunksize:%u hmac_offset:%u\n",
> + __func__, chunksize, hash_parms.hmac_offset);
> +
> + /* Prepend SPU header with type 3 BCM header */
> + memcpy(rctx->msg_buf.bcm_spu_req_hdr, BCMHEADER, BCM_HDR_LEN);
> +
> + spu_hdr_len = spu->spu_create_request(rctx->msg_buf.bcm_spu_req_hdr +
> + BCM_HDR_LEN, &req_opts,
> + &cipher_parms, &hash_parms,
> + &aead_parms, chunksize);
> +
> + /* Determine total length of padding. Put all padding in one buffer. */
> + db_size = spu_real_db_size(aead_parms.assoc_size, aead_parms.iv_len, 0,
> + chunksize, aead_parms.aad_pad_len,
> + aead_parms.data_pad_len, 0);
> +
> + stat_pad_len = spu->spu_wordalign_padlen(db_size);
> +
> + if (stat_pad_len)
> + rx_frag_num++;
> + pad_len = aead_parms.data_pad_len + stat_pad_len;
> + if (pad_len) {
> + tx_frag_num++;
> + spu->spu_request_pad(rctx->msg_buf.spu_req_pad,
> + aead_parms.data_pad_len, 0,
> + ctx->auth.alg, ctx->auth.mode,
> + rctx->total_sent, stat_pad_len);
> + }
> +
> + spu->spu_dump_msg_hdr(rctx->msg_buf.bcm_spu_req_hdr + BCM_HDR_LEN,
> + spu_hdr_len);
> + dump_sg(rctx->assoc, 0, aead_parms.assoc_size);
> + packet_dump(" aead iv: ", rctx->msg_buf.iv_ctr, aead_parms.iv_len);
> + packet_log("BD:\n");
> + dump_sg(rctx->src_sg, rctx->src_skip, chunksize);
> + packet_dump(" pad: ", rctx->msg_buf.spu_req_pad, pad_len);
> +
> + /*
> + * Build mailbox message containing SPU request msg and rx buffers
> + * to catch response message
> + */
> + memset(mssg, 0, sizeof(*mssg));
> + mssg->type = BRCM_MESSAGE_SPU;
> + mssg->ctx = rctx; /* Will be returned in response */
> +
> + /* Create rx scatterlist to catch result */
> + rx_frag_num += rctx->dst_nents;
> + resp_len = chunksize;
> +
> + /*
> + * Always catch ICV in separate buffer. Have to for GCM/CCM because of
> + * padding. Have to for SHA-224 and other truncated SHAs because SPU
> + * sends entire digest back.
> + */
> + rx_frag_num++;
> +
> + if (((ctx->cipher.mode == CIPHER_MODE_GCM) ||
> + (ctx->cipher.mode == CIPHER_MODE_CCM)) && !rctx->is_encrypt)
> + /*
> + * Input is ciphertxt plus ICV, but ICV not incl
> + * in output.
> + */
> + resp_len -= ctx->digestsize;
> +
> + err = spu_aead_rx_sg_create(mssg, req, rctx, rx_frag_num,
> + aead_parms.assoc_size,
> + aead_parms.ret_iv_len, resp_len, digestsize,
> + stat_pad_len);
> + if (err)
> + return err;
> +
> + /* Create tx scatterlist containing SPU request message */
> + tx_frag_num += rctx->src_nents;
> + tx_frag_num += assoc_nents;
> + if (aead_parms.aad_pad_len)
> + tx_frag_num++;
> + if (aead_parms.iv_len)
> + tx_frag_num++;
> + if (spu->spu_tx_status_len())
> + tx_frag_num++;
> + err = spu_aead_tx_sg_create(mssg, rctx, tx_frag_num, spu_hdr_len,
> + rctx->assoc, aead_parms.assoc_size,
> + assoc_nents, aead_parms.iv_len, chunksize,
> + aead_parms.aad_pad_len, pad_len, incl_icv);
> + if (err)
> + return err;
> +
> + err = mbox_send_message(iproc_priv.mbox[rctx->chan_idx], mssg);
> + if (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) {
> + while ((err == -ENOBUFS) && (retry_cnt < SPU_MB_RETRY_MAX)) {
> + /*
> + * Mailbox queue is full. Since MAY_SLEEP is set, assume
> + * not in atomic context and we can wait and try again.
> + */
> + retry_cnt++;
> + usleep_range(MBOX_SLEEP_MIN, MBOX_SLEEP_MAX);
> + err = mbox_send_message(iproc_priv.mbox[rctx->chan_idx],
> + mssg);
> + atomic_inc(&iproc_priv.mb_no_spc);
> + }
> + }
> + if (err < 0) {
> + atomic_inc(&iproc_priv.mb_send_fail);
> + return err;
> + }
> +
> + return -EINPROGRESS;
> +}
> +
> +/**
> + * handle_aead_resp() - Process a SPU response message for an AEAD request.
> + * @rctx: Crypto request context
> + */
> +static void handle_aead_resp(struct iproc_reqctx_s *rctx)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct crypto_async_request *areq = rctx->parent;
> + struct aead_request *req = container_of(areq,
> + struct aead_request, base);
> + struct iproc_ctx_s *ctx = rctx->ctx;
> + u32 payload_len;
> + unsigned int icv_offset;
> + u32 result_len;
> +
> + /* See how much data was returned */
> + payload_len = spu->spu_payload_length(rctx->msg_buf.spu_resp_hdr);
> + flow_log("payload_len %u\n", payload_len);
> +
> + /* only count payload */
> + atomic64_add(payload_len, &iproc_priv.bytes_in);
> +
> + if (req->assoclen)
> + packet_dump(" assoc_data ", rctx->msg_buf.a.resp_aad,
> + req->assoclen);
> +
> + /*
> + * Copy the ICV back to the destination
> + * buffer. In decrypt case, SPU gives us back the digest, but crypto
> + * API doesn't expect ICV in dst buffer.
> + */
> + result_len = req->cryptlen;
> + if (rctx->is_encrypt) {
> + icv_offset = req->assoclen + rctx->total_sent;
> + packet_dump(" ICV: ", rctx->msg_buf.digest, ctx->digestsize);
> + flow_log("copying ICV to dst sg at offset %u\n", icv_offset);
> + sg_copy_part_from_buf(req->dst, rctx->msg_buf.digest,
> + ctx->digestsize, icv_offset);
> + result_len += ctx->digestsize;
> + }
> +
> + packet_log("response data: ");
> + dump_sg(req->dst, req->assoclen, result_len);
> +
> + atomic_inc(&iproc_priv.op_counts[SPU_OP_AEAD]);
> + if (ctx->cipher.alg == CIPHER_ALG_AES) {
> + if (ctx->cipher.mode == CIPHER_MODE_CCM)
> + atomic_inc(&iproc_priv.aead_cnt[AES_CCM]);
> + else if (ctx->cipher.mode == CIPHER_MODE_GCM)
> + atomic_inc(&iproc_priv.aead_cnt[AES_GCM]);
> + else
> + atomic_inc(&iproc_priv.aead_cnt[AUTHENC]);
> + } else {
> + atomic_inc(&iproc_priv.aead_cnt[AUTHENC]);
> + }
> +}
> +
> +/**
> + * spu_chunk_cleanup() - Do cleanup after processing one chunk of a request
> + * @rctx: request context
> + *
> + * Mailbox scatterlists are allocated for each chunk. So free them after
> + * processing each chunk.
> + */
> +static void spu_chunk_cleanup(struct iproc_reqctx_s *rctx)
> +{
> + /* mailbox message used to tx request */
> + struct brcm_message *mssg = &rctx->mb_mssg;
> +
> + kfree(mssg->spu.src);
> + kfree(mssg->spu.dst);
> + memset(mssg, 0, sizeof(struct brcm_message));
> +}
> +
> +/**
> + * finish_req() - Used to invoke the complete callback from the requester when
> + * a request has been handled asynchronously.
> + * @rctx: Request context
> + * @err: Indicates whether the request was successful or not
> + *
> + * Ensures that cleanup has been done for request
> + */
> +static void finish_req(struct iproc_reqctx_s *rctx, int err)
> +{
> + struct crypto_async_request *areq = rctx->parent;
> +
> + flow_log("%s() err:%d\n\n", __func__, err);
> +
> + /* No harm done if already called */
> + spu_chunk_cleanup(rctx);
> +
> + if (areq)
> + areq->complete(areq, err);
> +}
> +
> +/**
> + * spu_rx_callback() - Callback from mailbox framework with a SPU response.
> + * @cl: mailbox client structure for SPU driver
> + * @msg: mailbox message containing SPU response
> + */
> +static void spu_rx_callback(struct mbox_client *cl, void *msg)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct device *dev = &iproc_priv.pdev->dev;
> + struct brcm_message *mssg = msg;
> + struct iproc_reqctx_s *rctx;
> + struct iproc_ctx_s *ctx;
> + struct crypto_async_request *areq;
> + int err = 0;
> +
> + rctx = mssg->ctx;
> + if (unlikely(!rctx)) {
> + /* This is fatal */
> + dev_err(dev, "%s(): no request context", __func__);
> + err = -EFAULT;
> + goto cb_finish;
> + }
> + areq = rctx->parent;
> + ctx = rctx->ctx;
> +
> + /* process the SPU status */
> + err = spu->spu_status_process(rctx->msg_buf.rx_stat);
> + if (err != 0) {
> + if (err == SPU_INVALID_ICV)
> + atomic_inc(&iproc_priv.bad_icv);
> + err = -EBADMSG;
> + goto cb_finish;
> + }
> +
> + /* Process the SPU response message */
> + switch (rctx->ctx->alg->type) {
> + case CRYPTO_ALG_TYPE_ABLKCIPHER:
> + handle_ablkcipher_resp(rctx);
> + break;
> + case CRYPTO_ALG_TYPE_AHASH:
> + handle_ahash_resp(rctx);
> + break;
> + case CRYPTO_ALG_TYPE_AEAD:
> + handle_aead_resp(rctx);
> + break;
> + default:
> + err = -EINVAL;
> + goto cb_finish;
> + }
> +
> + /*
> + * If this response does not complete the request, then send the next
> + * request chunk.
> + */
> + if (rctx->total_sent < rctx->total_todo) {
> + /* Deallocate anything specific to previous chunk */
> + spu_chunk_cleanup(rctx);
> +
> + switch (rctx->ctx->alg->type) {
> + case CRYPTO_ALG_TYPE_ABLKCIPHER:
> + err = handle_ablkcipher_req(rctx);
> + break;
> + case CRYPTO_ALG_TYPE_AHASH:
> + err = handle_ahash_req(rctx);
> + if (err == -EAGAIN)
> + /*
> + * we saved data in hash carry, but tell crypto
> + * API we successfully completed request.
> + */
> + err = 0;
> + break;
> + case CRYPTO_ALG_TYPE_AEAD:
> + err = handle_aead_req(rctx);
> + break;
> + default:
> + err = -EINVAL;
> + }
> +
> + if (err == -EINPROGRESS)
> + /* Successfully submitted request for next chunk */
> + return;
> + }
> +
> +cb_finish:
> + finish_req(rctx, err);
> +}
> +
> +/* ==================== Kernel Cryptographic API ==================== */
> +
> +/**
> + * ablkcipher_enqueue() - Handle ablkcipher encrypt or decrypt request.
> + * @req: Crypto API request
> + * @encrypt: true if encrypting; false if decrypting
> + *
> + * Return: -EINPROGRESS if request accepted and result will be returned
> + * asynchronously
> + * < 0 if an error
> + */
> +static int ablkcipher_enqueue(struct ablkcipher_request *req, bool encrypt)
> +{
> + struct iproc_reqctx_s *rctx = ablkcipher_request_ctx(req);
> + struct iproc_ctx_s *ctx =
> + crypto_ablkcipher_ctx(crypto_ablkcipher_reqtfm(req));
> + int err;
> +
> + flow_log("%s() enc:%u\n", __func__, encrypt);
> +
> + rctx->gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
> + CRYPTO_TFM_REQ_MAY_SLEEP)) ? GFP_KERNEL : GFP_ATOMIC;
> + rctx->parent = &req->base;
> + rctx->is_encrypt = encrypt;
> + rctx->bd_suppress = false;
> + rctx->total_todo = req->nbytes;
> + rctx->src_sent = 0;
> + rctx->total_sent = 0;
> + rctx->total_received = 0;
> + rctx->ctx = ctx;
> +
> + /* Initialize current position in src and dst scatterlists */
> + rctx->src_sg = req->src;
> + rctx->src_nents = 0;
> + rctx->src_skip = 0;
> + rctx->dst_sg = req->dst;
> + rctx->dst_nents = 0;
> + rctx->dst_skip = 0;
> +
> + if (ctx->cipher.mode == CIPHER_MODE_CBC ||
> + ctx->cipher.mode == CIPHER_MODE_CTR ||
> + ctx->cipher.mode == CIPHER_MODE_OFB ||
> + ctx->cipher.mode == CIPHER_MODE_XTS ||
> + ctx->cipher.mode == CIPHER_MODE_GCM ||
> + ctx->cipher.mode == CIPHER_MODE_CCM) {
> + rctx->iv_ctr_len =
> + crypto_ablkcipher_ivsize(crypto_ablkcipher_reqtfm(req));
> + memcpy(rctx->msg_buf.iv_ctr, req->info, rctx->iv_ctr_len);
> + } else {
> + rctx->iv_ctr_len = 0;
> + }
> +
> + /* Choose a SPU to process this request */
> + rctx->chan_idx = select_channel();
> + err = handle_ablkcipher_req(rctx);
> + if (err != -EINPROGRESS)
> + /* synchronous result */
> + spu_chunk_cleanup(rctx);
> +
> + return err;
> +}
> +
> +static int des_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
> + unsigned int keylen)
> +{
> + struct iproc_ctx_s *ctx = crypto_ablkcipher_ctx(cipher);
> + u32 tmp[DES_EXPKEY_WORDS];
> +
> + if (keylen == DES_KEY_SIZE) {
> + if (des_ekey(tmp, key) == 0) {
> + if (crypto_ablkcipher_get_flags(cipher) &
> + CRYPTO_TFM_REQ_WEAK_KEY) {
> + u32 flags = CRYPTO_TFM_RES_WEAK_KEY;
> +
> + crypto_ablkcipher_set_flags(cipher, flags);
> + return -EINVAL;
> + }
> + }
> +
> + ctx->cipher_type = CIPHER_TYPE_DES;
> + } else {
> + crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
> + return -EINVAL;
> + }
> + return 0;
> +}
> +
> +static int threedes_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
> + unsigned int keylen)
> +{
> + struct iproc_ctx_s *ctx = crypto_ablkcipher_ctx(cipher);
> +
> + if (keylen == (DES_KEY_SIZE * 3)) {
> + const u32 *K = (const u32 *)key;
> + u32 flags = CRYPTO_TFM_RES_BAD_KEY_SCHED;
> +
> + if (!((K[0] ^ K[2]) | (K[1] ^ K[3])) ||
> + !((K[2] ^ K[4]) | (K[3] ^ K[5]))) {
> + crypto_ablkcipher_set_flags(cipher, flags);
> + return -EINVAL;
> + }
> +
> + ctx->cipher_type = CIPHER_TYPE_3DES;
> + } else {
> + crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
> + return -EINVAL;
> + }
> + return 0;
> +}
> +
> +static int aes_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
> + unsigned int keylen)
> +{
> + struct iproc_ctx_s *ctx = crypto_ablkcipher_ctx(cipher);
> +
> + if (ctx->cipher.mode == CIPHER_MODE_XTS)
> + /* XTS includes two keys of equal length */
> + keylen = keylen / 2;
> +
> + switch (keylen) {
> + case AES_KEYSIZE_128:
> + ctx->cipher_type = CIPHER_TYPE_AES128;
> + break;
> + case AES_KEYSIZE_192:
> + ctx->cipher_type = CIPHER_TYPE_AES192;
> + break;
> + case AES_KEYSIZE_256:
> + ctx->cipher_type = CIPHER_TYPE_AES256;
> + break;
> + default:
> + crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
> + return -EINVAL;
> + }
> + WARN_ON((ctx->max_payload != SPU_MAX_PAYLOAD_INF) &&
> + ((ctx->max_payload % AES_BLOCK_SIZE) != 0));
> + return 0;
> +}
> +
> +static int rc4_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
> + unsigned int keylen)
> +{
> + struct iproc_ctx_s *ctx = crypto_ablkcipher_ctx(cipher);
> + int i;
> +
> + ctx->enckeylen = ARC4_MAX_KEY_SIZE + ARC4_STATE_SIZE;
> +
> + ctx->enckey[0] = 0x00; /* 0x00 */
> + ctx->enckey[1] = 0x00; /* i */
> + ctx->enckey[2] = 0x00; /* 0x00 */
> + ctx->enckey[3] = 0x00; /* j */
> + for (i = 0; i < ARC4_MAX_KEY_SIZE; i++)
> + ctx->enckey[i + ARC4_STATE_SIZE] = key[i % keylen];
> +
> + ctx->cipher_type = CIPHER_TYPE_INIT;
> +
> + return 0;
> +}
> +
> +static int ablkcipher_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
> + unsigned int keylen)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct iproc_ctx_s *ctx = crypto_ablkcipher_ctx(cipher);
> + struct spu_cipher_parms cipher_parms;
> + u32 alloc_len = 0;
> + int err;
> +
> + flow_log("ablkcipher_setkey() keylen: %d\n", keylen);
> + flow_dump(" key: ", key, keylen);
> +
> + switch (ctx->cipher.alg) {
> + case CIPHER_ALG_DES:
> + err = des_setkey(cipher, key, keylen);
> + break;
> + case CIPHER_ALG_3DES:
> + err = threedes_setkey(cipher, key, keylen);
> + break;
> + case CIPHER_ALG_AES:
> + err = aes_setkey(cipher, key, keylen);
> + break;
> + case CIPHER_ALG_RC4:
> + err = rc4_setkey(cipher, key, keylen);
> + break;
> + default:
> + pr_err("%s() Error: unknown cipher alg\n", __func__);
> + err = -EINVAL;
> + }
> + if (err)
> + return err;
> +
> + /* RC4 already populated ctx->enkey */
> + if (ctx->cipher.alg != CIPHER_ALG_RC4) {
> + memcpy(ctx->enckey, key, keylen);
> + ctx->enckeylen = keylen;
> + }
> + /* SPU needs XTS keys in the reverse order the crypto API presents */
> + if ((ctx->cipher.alg == CIPHER_ALG_AES) &&
> + (ctx->cipher.mode == CIPHER_MODE_XTS)) {
> + unsigned int xts_keylen = keylen / 2;
> +
> + memcpy(ctx->enckey, key + xts_keylen, xts_keylen);
> + memcpy(ctx->enckey + xts_keylen, key, xts_keylen);
> + }
> +
> + if (spu->spu_type == SPU_TYPE_SPUM)
> + alloc_len = BCM_HDR_LEN + SPU_HEADER_ALLOC_LEN;
> + else if (spu->spu_type == SPU_TYPE_SPU2)
> + alloc_len = BCM_HDR_LEN + SPU2_HEADER_ALLOC_LEN;
> + memset(ctx->bcm_spu_req_hdr, 0, alloc_len);
> + cipher_parms.iv_buf = NULL;
> + cipher_parms.iv_len = crypto_ablkcipher_ivsize(cipher);
> + flow_log("%s: iv_len %u\n", __func__, cipher_parms.iv_len);
> +
> + cipher_parms.alg = ctx->cipher.alg;
> + cipher_parms.mode = ctx->cipher.mode;
> + cipher_parms.type = ctx->cipher_type;
> + cipher_parms.key_buf = ctx->enckey;
> + cipher_parms.key_len = ctx->enckeylen;
> +
> + /* Prepend SPU request message with BCM header */
> + memcpy(ctx->bcm_spu_req_hdr, BCMHEADER, BCM_HDR_LEN);
> + ctx->spu_req_hdr_len =
> + spu->spu_cipher_req_init(ctx->bcm_spu_req_hdr + BCM_HDR_LEN,
> + &cipher_parms);
> +
> + ctx->spu_resp_hdr_len = spu->spu_response_hdr_len(ctx->authkeylen,
> + ctx->enckeylen,
> + false);
> +
> + atomic_inc(&iproc_priv.setkey_cnt[SPU_OP_CIPHER]);
> +
> + return 0;
> +}
> +
> +static int ablkcipher_encrypt(struct ablkcipher_request *req)
> +{
> + flow_log("ablkcipher_encrypt() nbytes:%u\n", req->nbytes);
> +
> + return ablkcipher_enqueue(req, true);
> +}
> +
> +static int ablkcipher_decrypt(struct ablkcipher_request *req)
> +{
> + flow_log("ablkcipher_decrypt() nbytes:%u\n", req->nbytes);
> + return ablkcipher_enqueue(req, false);
> +}
> +
> +static int ahash_enqueue(struct ahash_request *req)
> +{
> + struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
> + struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
> + struct iproc_ctx_s *ctx = crypto_ahash_ctx(tfm);
> + int err = 0;
> + const char *alg_name;
> +
> + flow_log("ahash_enqueue() nbytes:%u\n", req->nbytes);
> +
> + rctx->gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
> + CRYPTO_TFM_REQ_MAY_SLEEP)) ? GFP_KERNEL : GFP_ATOMIC;
> + rctx->parent = &req->base;
> + rctx->ctx = ctx;
> + rctx->bd_suppress = true;
> + memset(&rctx->mb_mssg, 0, sizeof(struct brcm_message));
> +
> + /* Initialize position in src scatterlist */
> + rctx->src_sg = req->src;
> + rctx->src_skip = 0;
> + rctx->src_nents = 0;
> + rctx->dst_sg = NULL;
> + rctx->dst_skip = 0;
> + rctx->dst_nents = 0;
> +
> + /* SPU2 hardware does not compute hash of zero length data */
> + if ((rctx->is_final == 1) && (rctx->total_todo == 0) &&
> + (iproc_priv.spu.spu_type == SPU_TYPE_SPU2)) {
> + alg_name = crypto_tfm_alg_name(crypto_ahash_tfm(tfm));
> + flow_log("Doing %sfinal %s zero-len hash request in software\n",
> + rctx->is_final ? "" : "non-", alg_name);
> + err = do_shash((unsigned char *)alg_name, req->result,
> + NULL, 0, NULL, 0, ctx->authkey,
> + ctx->authkeylen);
> + if (err < 0)
> + flow_log("Hash request failed with error %d\n", err);
> + return err;
> + }
> + /* Choose a SPU to process this request */
> + rctx->chan_idx = select_channel();
> +
> + err = handle_ahash_req(rctx);
> + if (err != -EINPROGRESS)
> + /* synchronous result */
> + spu_chunk_cleanup(rctx);
> +
> + if (err == -EAGAIN)
> + /*
> + * we saved data in hash carry, but tell crypto API
> + * we successfully completed request.
> + */
> + err = 0;
> +
> + return err;
> +}
> +
> +static int __ahash_init(struct ahash_request *req)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
> + struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
> + struct iproc_ctx_s *ctx = crypto_ahash_ctx(tfm);
> +
> + flow_log("%s()\n", __func__);
> +
> + /* Initialize the context */
> + rctx->hash_carry_len = 0;
> + rctx->is_final = 0;
> +
> + rctx->total_todo = 0;
> + rctx->src_sent = 0;
> + rctx->total_sent = 0;
> + rctx->total_received = 0;
> +
> + ctx->digestsize = crypto_ahash_digestsize(tfm);
> + /* If we add a hash whose digest is larger, catch it here. */
> + WARN_ON(ctx->digestsize > MAX_DIGEST_SIZE);
> +
> + rctx->is_sw_hmac = false;
> +
> + ctx->spu_resp_hdr_len = spu->spu_response_hdr_len(ctx->authkeylen, 0,
> + true);
> +
> + return 0;
> +}
> +
> +/**
> + * spu_no_incr_hash() - Determine whether incremental hashing is supported.
> + * @ctx: Crypto session context
> + *
> + * SPU-2 does not support incremental hashing (we'll have to revisit and
> + * condition based on chip revision or device tree entry if future versions do
> + * support incremental hash)
> + *
> + * SPU-M also doesn't support incremental hashing of AES-XCBC
> + *
> + * Return: true if incremental hashing is not supported
> + * false otherwise
> + */
> +bool spu_no_incr_hash(struct iproc_ctx_s *ctx)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> +
> + if (spu->spu_type == SPU_TYPE_SPU2)
> + return true;
> +
> + if ((ctx->auth.alg == HASH_ALG_AES) &&
> + (ctx->auth.mode == HASH_MODE_XCBC))
> + return true;
> +
> + /* Otherwise, incremental hashing is supported */
> + return false;
> +}
> +
> +static int ahash_init(struct ahash_request *req)
> +{
> + struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
> + struct iproc_ctx_s *ctx = crypto_ahash_ctx(tfm);
> + const char *alg_name;
> + struct crypto_shash *hash;
> + int ret;
> + gfp_t gfp;
> +
> + if (spu_no_incr_hash(ctx)) {
> + /*
> + * If we get an incremental hashing request and it's not
> + * supported by the hardware, we need to handle it in software
> + * by calling synchronous hash functions.
> + */
> + alg_name = crypto_tfm_alg_name(crypto_ahash_tfm(tfm));
> + hash = crypto_alloc_shash(alg_name, 0, 0);
> + if (IS_ERR(hash)) {
> + ret = PTR_ERR(hash);
> + return ret;
> + }
> +
> + gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
> + CRYPTO_TFM_REQ_MAY_SLEEP)) ? GFP_KERNEL : GFP_ATOMIC;
> + ctx->shash = kmalloc(sizeof(*ctx->shash) +
> + crypto_shash_descsize(hash), gfp);
> + if (!ctx->shash) {
> + crypto_free_shash(hash);
> + return -ENOMEM;
> + }
> + ctx->shash->tfm = hash;
> + ctx->shash->flags = 0;
> +
> + /* Set the key using data we already have from setkey */
> + if (ctx->authkeylen > 0) {
> + ret = crypto_shash_setkey(hash, ctx->authkey,
> + ctx->authkeylen);
> + if (ret) {
> + crypto_free_shash(hash);
> + kfree(ctx->shash);
> + return ret;
> + }
> + }
> +
> + /* Initialize hash w/ this key and other params */
> + ret = crypto_shash_init(ctx->shash);
> + if (ret) {
> + crypto_free_shash(hash);
> + kfree(ctx->shash);
> + return ret;
> + }
> + } else {
> + /* Otherwise call the internal function which uses SPU hw */
> + ret = __ahash_init(req);
> + }
> +
> + return ret;
> +}
> +
> +static int __ahash_update(struct ahash_request *req)
> +{
> + struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
> +
> + flow_log("ahash_update() nbytes:%u\n", req->nbytes);
> +
> + if (!req->nbytes)
> + return 0;
> + rctx->total_todo += req->nbytes;
> + rctx->src_sent = 0;
> +
> + return ahash_enqueue(req);
> +}
> +
> +static int ahash_update(struct ahash_request *req)
> +{
> + struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
> + struct iproc_ctx_s *ctx = crypto_ahash_ctx(tfm);
> + u8 *tmpbuf;
> + int ret;
> + int nents;
> + gfp_t gfp;
> +
> + if (spu_no_incr_hash(ctx)) {
> + /*
> + * If we get an incremental hashing request and it's not
> + * supported by the hardware, we need to handle it in software
> + * by calling synchronous hash functions.
> + */
> + if (req->src)
> + nents = sg_nents(req->src);
> + else
> + return -EINVAL;
> +
> + /* Copy data from req scatterlist to tmp buffer */
> + gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
> + CRYPTO_TFM_REQ_MAY_SLEEP)) ? GFP_KERNEL : GFP_ATOMIC;
> + tmpbuf = kmalloc(req->nbytes, gfp);
> + if (!tmpbuf)
> + return -ENOMEM;
> +
> + if (sg_copy_to_buffer(req->src, nents, tmpbuf, req->nbytes) !=
> + req->nbytes) {
> + kfree(tmpbuf);
> + return -EINVAL;
> + }
> +
> + /* Call synchronous update */
> + ret = crypto_shash_update(ctx->shash, tmpbuf, req->nbytes);
> + kfree(tmpbuf);
> + } else {
> + /* Otherwise call the internal function which uses SPU hw */
> + ret = __ahash_update(req);
> + }
> +
> + return ret;
> +}
> +
> +static int __ahash_final(struct ahash_request *req)
> +{
> + struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
> +
> + flow_log("ahash_final() nbytes:%u\n", req->nbytes);
> +
> + rctx->is_final = 1;
> +
> + return ahash_enqueue(req);
> +}
> +
> +static int ahash_final(struct ahash_request *req)
> +{
> + struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
> + struct iproc_ctx_s *ctx = crypto_ahash_ctx(tfm);
> + int ret;
> +
> + if (spu_no_incr_hash(ctx)) {
> + /*
> + * If we get an incremental hashing request and it's not
> + * supported by the hardware, we need to handle it in software
> + * by calling synchronous hash functions.
> + */
> + ret = crypto_shash_final(ctx->shash, req->result);
> +
> + /* Done with hash, can deallocate it now */
> + crypto_free_shash(ctx->shash->tfm);
> + kfree(ctx->shash);
> +
> + } else {
> + /* Otherwise call the internal function which uses SPU hw */
> + ret = __ahash_final(req);
> + }
> +
> + return ret;
> +}
> +
> +static int __ahash_finup(struct ahash_request *req)
> +{
> + struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
> +
> + flow_log("ahash_finup() nbytes:%u\n", req->nbytes);
> +
> + rctx->total_todo += req->nbytes;
> + rctx->src_sent = 0;
> + rctx->is_final = 1;
> +
> + return ahash_enqueue(req);
> +}
> +
> +static int ahash_finup(struct ahash_request *req)
> +{
> + struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
> + struct iproc_ctx_s *ctx = crypto_ahash_ctx(tfm);
> + u8 *tmpbuf;
> + int ret;
> + int nents;
> + gfp_t gfp;
> +
> + if (spu_no_incr_hash(ctx)) {
> + /*
> + * If we get an incremental hashing request and it's not
> + * supported by the hardware, we need to handle it in software
> + * by calling synchronous hash functions.
> + */
> + if (req->src) {
> + nents = sg_nents(req->src);
> + } else {
> + ret = -EINVAL;
> + goto ahash_finup_exit;
> + }
> +
> + /* Copy data from req scatterlist to tmp buffer */
> + gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
> + CRYPTO_TFM_REQ_MAY_SLEEP)) ? GFP_KERNEL : GFP_ATOMIC;
> + tmpbuf = kmalloc(req->nbytes, gfp);
> + if (!tmpbuf) {
> + ret = -ENOMEM;
> + goto ahash_finup_exit;
> + }
> +
> + if (sg_copy_to_buffer(req->src, nents, tmpbuf, req->nbytes) !=
> + req->nbytes) {
> + kfree(tmpbuf);
> + ret = -EINVAL;
> + goto ahash_finup_exit;
> + }
> +
> + /* Call synchronous update */
> + ret = crypto_shash_finup(ctx->shash, tmpbuf, req->nbytes,
> + req->result);
> + kfree(tmpbuf);
> + } else {
> + /* Otherwise call the internal function which uses SPU hw */
> + return __ahash_finup(req);
> + }
> +
> +ahash_finup_exit:
> + /* Done with hash, can deallocate it now */
> + crypto_free_shash(ctx->shash->tfm);
> + kfree(ctx->shash);
> + return ret;
> +}
> +
> +static int ahash_digest(struct ahash_request *req)
> +{
> + int err = 0;
> +
> + flow_log("ahash_digest() nbytes:%u\n", req->nbytes);
> +
> + /* whole thing at once */
> + err = __ahash_init(req);
> + if (!err)
> + err = __ahash_finup(req);
> +
> + return err;
> +}
> +
> +static int ahash_setkey(struct crypto_ahash *ahash, const u8 *key,
> + unsigned int keylen)
> +{
> + struct iproc_ctx_s *ctx = crypto_ahash_ctx(ahash);
> +
> + flow_log("%s() ahash:%p key:%p keylen:%u\n",
> + __func__, ahash, key, keylen);
> + flow_dump(" key: ", key, keylen);
> +
> + if (ctx->auth.alg == HASH_ALG_AES) {
> + switch (keylen) {
> + case AES_KEYSIZE_128:
> + ctx->cipher_type = CIPHER_TYPE_AES128;
> + break;
> + case AES_KEYSIZE_192:
> + ctx->cipher_type = CIPHER_TYPE_AES192;
> + break;
> + case AES_KEYSIZE_256:
> + ctx->cipher_type = CIPHER_TYPE_AES256;
> + break;
> + default:
> + pr_err("%s() Error: Invalid key length\n", __func__);
> + return -EINVAL;
> + }
> + } else {
> + pr_err("%s() Error: unknown hash alg\n", __func__);
> + return -EINVAL;
> + }
> + memcpy(ctx->authkey, key, keylen);
> + ctx->authkeylen = keylen;
> +
> + return 0;
> +}
> +
> +static int ahash_export(struct ahash_request *req, void *out)
> +{
> + const struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
> +
> + memcpy(out, rctx, offsetof(struct iproc_reqctx_s, msg_buf));
> + return 0;
> +}
> +
> +static int ahash_import(struct ahash_request *req, const void *in)
> +{
> + struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
> +
> + memcpy(rctx, in, offsetof(struct iproc_reqctx_s, msg_buf));
> + return 0;
> +}
> +
> +static int ahash_hmac_setkey(struct crypto_ahash *ahash, const u8 *key,
> + unsigned int keylen)
> +{
> + struct iproc_ctx_s *ctx = crypto_ahash_ctx(ahash);
> + unsigned int blocksize =
> + crypto_tfm_alg_blocksize(crypto_ahash_tfm(ahash));
> + unsigned int digestsize = crypto_ahash_digestsize(ahash);
> + unsigned int index;
> + int rc;
> +
> + flow_log("%s() ahash:%p key:%p keylen:%u blksz:%u digestsz:%u\n",
> + __func__, ahash, key, keylen, blocksize, digestsize);
> + flow_dump(" key: ", key, keylen);
> +
> + if (keylen > blocksize) {
> + switch (ctx->auth.alg) {
> + case HASH_ALG_MD5:
> + rc = do_shash("md5", ctx->authkey, key, keylen, NULL,
> + 0, NULL, 0);
> + break;
> + case HASH_ALG_SHA1:
> + rc = do_shash("sha1", ctx->authkey, key, keylen, NULL,
> + 0, NULL, 0);
> + break;
> + case HASH_ALG_SHA224:
> + rc = do_shash("sha224", ctx->authkey, key, keylen, NULL,
> + 0, NULL, 0);
> + break;
> + case HASH_ALG_SHA256:
> + rc = do_shash("sha256", ctx->authkey, key, keylen, NULL,
> + 0, NULL, 0);
> + break;
> + case HASH_ALG_SHA384:
> + rc = do_shash("sha384", ctx->authkey, key, keylen, NULL,
> + 0, NULL, 0);
> + break;
> + case HASH_ALG_SHA512:
> + rc = do_shash("sha512", ctx->authkey, key, keylen, NULL,
> + 0, NULL, 0);
> + break;
> + case HASH_ALG_SHA3_224:
> + rc = do_shash("sha3-224", ctx->authkey, key, keylen,
> + NULL, 0, NULL, 0);
> + break;
> + case HASH_ALG_SHA3_256:
> + rc = do_shash("sha3-256", ctx->authkey, key, keylen,
> + NULL, 0, NULL, 0);
> + break;
> + case HASH_ALG_SHA3_384:
> + rc = do_shash("sha3-384", ctx->authkey, key, keylen,
> + NULL, 0, NULL, 0);
> + break;
> + case HASH_ALG_SHA3_512:
> + rc = do_shash("sha3-512", ctx->authkey, key, keylen,
> + NULL, 0, NULL, 0);
> + break;
> + default:
> + pr_err("%s() Error: unknown hash alg\n", __func__);
> + return -EINVAL;
> + }
> + if (rc < 0) {
> + pr_err("%s() Error %d computing shash for %s\n",
> + __func__, rc, hash_alg_name[ctx->auth.alg]);
> + return rc;
> + }
> + ctx->authkeylen = digestsize;
> +
> + flow_log(" keylen > digestsize... hashed\n");
> + flow_dump(" newkey: ", ctx->authkey, ctx->authkeylen);
> + } else {
> + memcpy(ctx->authkey, key, keylen);
> + ctx->authkeylen = keylen;
> + }
> +
> + /*
> + * Full HMAC operation in SPUM is not verified,
> + * So keeping the generation of IPAD, OPAD and
> + * outer hashing in software.
> + */
> + if (iproc_priv.spu.spu_type == SPU_TYPE_SPUM) {
> + memcpy(ctx->ipad, ctx->authkey, ctx->authkeylen);
> + memset(ctx->ipad + ctx->authkeylen, 0,
> + blocksize - ctx->authkeylen);
> + ctx->authkeylen = 0;
> + memcpy(ctx->opad, ctx->ipad, blocksize);
> +
> + for (index = 0; index < blocksize; index++) {
> + ctx->ipad[index] ^= 0x36;
> + ctx->opad[index] ^= 0x5c;
> + }
> +
> + flow_dump(" ipad: ", ctx->ipad, blocksize);
> + flow_dump(" opad: ", ctx->opad, blocksize);
> + }
> + ctx->digestsize = digestsize;
> + atomic_inc(&iproc_priv.setkey_cnt[SPU_OP_HMAC]);
> +
> + return 0;
> +}
> +
> +static int ahash_hmac_init(struct ahash_request *req)
> +{
> + struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
> + struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
> + struct iproc_ctx_s *ctx = crypto_ahash_ctx(tfm);
> + unsigned int blocksize =
> + crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm));
> +
> + flow_log("ahash_hmac_init()\n");
> +
> + /* init the context as a hash */
> + ahash_init(req);
> +
> + if (!spu_no_incr_hash(ctx)) {
> + /* SPU-M can do incr hashing but needs sw for outer HMAC */
> + rctx->is_sw_hmac = true;
> + ctx->auth.mode = HASH_MODE_HASH;
> + /* start with a prepended ipad */
> + memcpy(rctx->hash_carry, ctx->ipad, blocksize);
> + rctx->hash_carry_len = blocksize;
> + rctx->total_todo += blocksize;
> + }
> +
> + return 0;
> +}
> +
> +static int ahash_hmac_update(struct ahash_request *req)
> +{
> + flow_log("ahash_hmac_update() nbytes:%u\n", req->nbytes);
> +
> + if (!req->nbytes)
> + return 0;
> +
> + return ahash_update(req);
> +}
> +
> +static int ahash_hmac_final(struct ahash_request *req)
> +{
> + flow_log("ahash_hmac_final() nbytes:%u\n", req->nbytes);
> +
> + return ahash_final(req);
> +}
> +
> +static int ahash_hmac_finup(struct ahash_request *req)
> +{
> + flow_log("ahash_hmac_finupl() nbytes:%u\n", req->nbytes);
> +
> + return ahash_finup(req);
> +}
> +
> +static int ahash_hmac_digest(struct ahash_request *req)
> +{
> + struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
> + struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
> + struct iproc_ctx_s *ctx = crypto_ahash_ctx(tfm);
> + unsigned int blocksize =
> + crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm));
> +
> + flow_log("ahash_hmac_digest() nbytes:%u\n", req->nbytes);
> +
> + /* Perform initialization and then call finup */
> + __ahash_init(req);
> +
> + if (iproc_priv.spu.spu_type == SPU_TYPE_SPU2) {
> + /*
> + * SPU2 supports full HMAC implementation in the
> + * hardware, need not to generate IPAD, OPAD and
> + * outer hash in software.
> + * Only for hash key len > hash block size, SPU2
> + * expects to perform hashing on the key, shorten
> + * it to digest size and feed it as hash key.
> + */
> + rctx->is_sw_hmac = false;
> + ctx->auth.mode = HASH_MODE_HMAC;
> + } else {
> + rctx->is_sw_hmac = true;
> + ctx->auth.mode = HASH_MODE_HASH;
> + /* start with a prepended ipad */
> + memcpy(rctx->hash_carry, ctx->ipad, blocksize);
> + rctx->hash_carry_len = blocksize;
> + rctx->total_todo += blocksize;
> + }
> +
> + return __ahash_finup(req);
> +}
> +
> +/* aead helpers */
> +
> +static int aead_need_fallback(struct aead_request *req)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct crypto_aead *aead = crypto_aead_reqtfm(req);
> + struct iproc_ctx_s *ctx = crypto_aead_ctx(aead);
> + u32 payload_len;
> +
> + /*
> + * SPU hardware cannot handle the AES-GCM/CCM case where plaintext
> + * and AAD are both 0 bytes long. So use fallback in this case.
> + */
> + if (((ctx->cipher.mode == CIPHER_MODE_GCM) ||
> + (ctx->cipher.mode == CIPHER_MODE_CCM)) &&
> + (req->cryptlen + req->assoclen) == 0) {
> + flow_log("%s() AES GCM/CCM needs fallback for 0 len request\n",
> + __func__);
> + return 1;
> + }
> +
> + /* SPU-M hardware only supports CCM digest size of 8, 12, or 16 bytes */
> + if ((ctx->cipher.mode == CIPHER_MODE_CCM) &&
> + (spu->spu_type == SPU_TYPE_SPUM) &&
> + (ctx->digestsize != 8) && (ctx->digestsize != 12) &&
> + (ctx->digestsize != 16)) {
> + flow_log("%s() AES CCM needs fallbck for digest size %d\n",
> + __func__, ctx->digestsize);
> + return 1;
> + }
> +
> + /*
> + * SPU-M on NSP has an issue where AES-CCM hash is not correct
> + * when AAD size is 0
> + */
> + if ((ctx->cipher.mode == CIPHER_MODE_CCM) &&
> + (spu->spu_subtype == SPU_SUBTYPE_SPUM_NSP) &&
> + (req->assoclen == 0)) {
> + flow_log("%s() AES_CCM needs fallback for 0 len AAD on NSP\n",
> + __func__);
> + return 1;
> + }
> +
> + payload_len = req->cryptlen;
> + if (spu->spu_type == SPU_TYPE_SPUM)
> + payload_len += req->assoclen;
> +
> + flow_log("%s() payload len: %u\n", __func__, payload_len);
> +
> + if (ctx->max_payload == SPU_MAX_PAYLOAD_INF)
> + return 0;
> + else
> + return payload_len > ctx->max_payload;
> +}
> +
> +static void aead_complete(struct crypto_async_request *areq, int err)
> +{
> + struct aead_request *req =
> + container_of(areq, struct aead_request, base);
> + struct iproc_reqctx_s *rctx = aead_request_ctx(req);
> + struct crypto_aead *aead = crypto_aead_reqtfm(req);
> +
> + flow_log("%s() err:%d\n", __func__, err);
> +
> + areq->tfm = crypto_aead_tfm(aead);
> +
> + areq->complete = rctx->old_complete;
> + areq->data = rctx->old_data;
> +
> + areq->complete(areq, err);
> +}
> +
> +static int aead_do_fallback(struct aead_request *req, bool is_encrypt)
> +{
> + struct crypto_aead *aead = crypto_aead_reqtfm(req);
> + struct crypto_tfm *tfm = crypto_aead_tfm(aead);
> + struct iproc_reqctx_s *rctx = aead_request_ctx(req);
> + struct iproc_ctx_s *ctx = crypto_tfm_ctx(tfm);
> + int err;
> + u32 req_flags;
> +
> + flow_log("%s() enc:%u\n", __func__, is_encrypt);
> +
> + if (ctx->fallback_cipher) {
> + /* Store the cipher tfm and then use the fallback tfm */
> + rctx->old_tfm = tfm;
> + aead_request_set_tfm(req, ctx->fallback_cipher);
> + /*
> + * Save the callback and chain ourselves in, so we can restore
> + * the tfm
> + */
> + rctx->old_complete = req->base.complete;
> + rctx->old_data = req->base.data;
> + req_flags = aead_request_flags(req);
> + aead_request_set_callback(req, req_flags, aead_complete, req);
> + err = is_encrypt ? crypto_aead_encrypt(req) :
> + crypto_aead_decrypt(req);
> +
> + if (err == 0) {
> + /*
> + * fallback was synchronous (did not return
> + * -EINPROGRESS). So restore request state here.
> + */
> + aead_request_set_callback(req, req_flags,
> + rctx->old_complete, req);
> + req->base.data = rctx->old_data;
> + aead_request_set_tfm(req, aead);
> + flow_log("%s() fallback completed successfully\n\n",
> + __func__);
> + }
> + } else {
> + err = -EINVAL;
> + }
> +
> + return err;
> +}
> +
> +static int aead_enqueue(struct aead_request *req, bool is_encrypt)
> +{
> + struct iproc_reqctx_s *rctx = aead_request_ctx(req);
> + struct crypto_aead *aead = crypto_aead_reqtfm(req);
> + struct iproc_ctx_s *ctx = crypto_aead_ctx(aead);
> + int err;
> +
> + flow_log("%s() enc:%u\n", __func__, is_encrypt);
> +
> + if (req->assoclen > MAX_ASSOC_SIZE) {
> + pr_err
> + ("%s() Error: associated data too long. (%u > %u bytes)\n",
> + __func__, req->assoclen, MAX_ASSOC_SIZE);
> + return -EINVAL;
> + }
> +
> + rctx->gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
> + CRYPTO_TFM_REQ_MAY_SLEEP)) ? GFP_KERNEL : GFP_ATOMIC;
> + rctx->parent = &req->base;
> + rctx->is_encrypt = is_encrypt;
> + rctx->bd_suppress = false;
> + rctx->total_todo = req->cryptlen;
> + rctx->src_sent = 0;
> + rctx->total_sent = 0;
> + rctx->total_received = 0;
> + rctx->is_sw_hmac = false;
> + rctx->ctx = ctx;
> + memset(&rctx->mb_mssg, 0, sizeof(struct brcm_message));
> +
> + /* assoc data is at start of src sg */
> + rctx->assoc = req->src;
> +
> + /*
> + * Init current position in src scatterlist to be after assoc data.
> + * src_skip set to buffer offset where data begins. (Assoc data could
> + * end in the middle of a buffer.)
> + */
> + if (spu_sg_at_offset(req->src, req->assoclen, &rctx->src_sg,
> + &rctx->src_skip) < 0) {
> + pr_err("%s() Error: Unable to find start of src data\n",
> + __func__);
> + return -EINVAL;
> + }
> +
> + rctx->src_nents = 0;
> + rctx->dst_nents = 0;
> + if (req->dst == req->src) {
> + rctx->dst_sg = rctx->src_sg;
> + rctx->dst_skip = rctx->src_skip;
> + } else {
> + /*
> + * Expect req->dst to have room for assoc data followed by
> + * output data and ICV, if encrypt. So initialize dst_sg
> + * to point beyond assoc len offset.
> + */
> + if (spu_sg_at_offset(req->dst, req->assoclen, &rctx->dst_sg,
> + &rctx->dst_skip) < 0) {
> + pr_err("%s() Error: Unable to find start of dst data\n",
> + __func__);
> + return -EINVAL;
> + }
> + }
> +
> + if (ctx->cipher.mode == CIPHER_MODE_CBC ||
> + ctx->cipher.mode == CIPHER_MODE_CTR ||
> + ctx->cipher.mode == CIPHER_MODE_OFB ||
> + ctx->cipher.mode == CIPHER_MODE_XTS ||
> + ctx->cipher.mode == CIPHER_MODE_GCM) {
> + rctx->iv_ctr_len =
> + ctx->salt_len +
> + crypto_aead_ivsize(crypto_aead_reqtfm(req));
> + } else if (ctx->cipher.mode == CIPHER_MODE_CCM) {
> + rctx->iv_ctr_len = CCM_AES_IV_SIZE;
> + } else {
> + rctx->iv_ctr_len = 0;
> + }
> +
> + rctx->hash_carry_len = 0;
> +
> + flow_log(" src sg: %p\n", req->src);
> + flow_log(" rctx->src_sg: %p, src_skip %u\n",
> + rctx->src_sg, rctx->src_skip);
> + flow_log(" assoc: %p, assoclen %u\n", rctx->assoc, req->assoclen);
> + flow_log(" dst sg: %p\n", req->dst);
> + flow_log(" rctx->dst_sg: %p, dst_skip %u\n",
> + rctx->dst_sg, rctx->dst_skip);
> + flow_log(" iv_ctr_len:%u\n", rctx->iv_ctr_len);
> + flow_dump(" iv: ", req->iv, rctx->iv_ctr_len);
> + flow_log(" authkeylen:%u\n", ctx->authkeylen);
> + flow_log(" is_esp: %s\n", ctx->is_esp ? "yes" : "no");
> +
> + if (ctx->max_payload == SPU_MAX_PAYLOAD_INF)
> + flow_log(" max_payload infinite");
> + else
> + flow_log(" max_payload: %u\n", ctx->max_payload);
> +
> + if (unlikely(aead_need_fallback(req)))
> + return aead_do_fallback(req, is_encrypt);
> +
> + /*
> + * Do memory allocations for request after fallback check, because if we
> + * do fallback, we won't call finish_req() to dealloc.
> + */
> + if (rctx->iv_ctr_len) {
> + if (ctx->salt_len)
> + memcpy(rctx->msg_buf.iv_ctr + ctx->salt_offset,
> + ctx->salt, ctx->salt_len);
> + memcpy(rctx->msg_buf.iv_ctr + ctx->salt_offset + ctx->salt_len,
> + req->iv,
> + rctx->iv_ctr_len - ctx->salt_len - ctx->salt_offset);
> + }
> +
> + rctx->chan_idx = select_channel();
> + err = handle_aead_req(rctx);
> + if (err != -EINPROGRESS)
> + /* synchronous result */
> + spu_chunk_cleanup(rctx);
> +
> + return err;
> +}
> +
> +static int aead_authenc_setkey(struct crypto_aead *cipher,
> + const u8 *key, unsigned int keylen)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct iproc_ctx_s *ctx = crypto_aead_ctx(cipher);
> + struct crypto_tfm *tfm = crypto_aead_tfm(cipher);
> + struct rtattr *rta = (void *)key;
> + struct crypto_authenc_key_param *param;
> + const u8 *origkey = key;
> + const unsigned int origkeylen = keylen;
> +
> + int ret = 0;
> +
> + flow_log("%s() aead:%p key:%p keylen:%u\n", __func__, cipher, key,
> + keylen);
> + flow_dump(" key: ", key, keylen);
> +
> + if (!RTA_OK(rta, keylen))
> + goto badkey;
> + if (rta->rta_type != CRYPTO_AUTHENC_KEYA_PARAM)
> + goto badkey;
> + if (RTA_PAYLOAD(rta) < sizeof(*param))
> + goto badkey;
> +
> + param = RTA_DATA(rta);
> + ctx->enckeylen = be32_to_cpu(param->enckeylen);
> +
> + key += RTA_ALIGN(rta->rta_len);
> + keylen -= RTA_ALIGN(rta->rta_len);
> +
> + if (keylen < ctx->enckeylen)
> + goto badkey;
> + if (ctx->enckeylen > MAX_KEY_SIZE)
> + goto badkey;
> +
> + ctx->authkeylen = keylen - ctx->enckeylen;
> +
> + if (ctx->authkeylen > MAX_KEY_SIZE)
> + goto badkey;
> +
> + memcpy(ctx->enckey, key + ctx->authkeylen, ctx->enckeylen);
> + /* May end up padding auth key. So make sure it's zeroed. */
> + memset(ctx->authkey, 0, sizeof(ctx->authkey));
> + memcpy(ctx->authkey, key, ctx->authkeylen);
> +
> + switch (ctx->alg->cipher_info.alg) {
> + case CIPHER_ALG_DES:
> + if (ctx->enckeylen == DES_KEY_SIZE) {
> + u32 tmp[DES_EXPKEY_WORDS];
> + u32 flags = CRYPTO_TFM_RES_WEAK_KEY;
> +
> + if (des_ekey(tmp, key) == 0) {
> + if (crypto_aead_get_flags(cipher) &
> + CRYPTO_TFM_REQ_WEAK_KEY) {
> + crypto_aead_set_flags(cipher, flags);
> + return -EINVAL;
> + }
> + }
> +
> + ctx->cipher_type = CIPHER_TYPE_DES;
> + } else {
> + goto badkey;
> + }
> + break;
> + case CIPHER_ALG_3DES:
> + if (ctx->enckeylen == (DES_KEY_SIZE * 3)) {
> + const u32 *K = (const u32 *)key;
> + u32 flags = CRYPTO_TFM_RES_BAD_KEY_SCHED;
> +
> + if (!((K[0] ^ K[2]) | (K[1] ^ K[3])) ||
> + !((K[2] ^ K[4]) | (K[3] ^ K[5]))) {
> + crypto_aead_set_flags(cipher, flags);
> + return -EINVAL;
> + }
> +
> + ctx->cipher_type = CIPHER_TYPE_3DES;
> + } else {
> + crypto_aead_set_flags(cipher,
> + CRYPTO_TFM_RES_BAD_KEY_LEN);
> + return -EINVAL;
> + }
> + break;
> + case CIPHER_ALG_AES:
> + switch (ctx->enckeylen) {
> + case AES_KEYSIZE_128:
> + ctx->cipher_type = CIPHER_TYPE_AES128;
> + break;
> + case AES_KEYSIZE_192:
> + ctx->cipher_type = CIPHER_TYPE_AES192;
> + break;
> + case AES_KEYSIZE_256:
> + ctx->cipher_type = CIPHER_TYPE_AES256;
> + break;
> + default:
> + goto badkey;
> + }
> + break;
> + case CIPHER_ALG_RC4:
> + ctx->cipher_type = CIPHER_TYPE_INIT;
> + break;
> + default:
> + pr_err("%s() Error: Unknown cipher alg\n", __func__);
> + return -EINVAL;
> + }
> +
> + flow_log(" enckeylen:%u authkeylen:%u\n", ctx->enckeylen,
> + ctx->authkeylen);
> + flow_dump(" enc: ", ctx->enckey, ctx->enckeylen);
> + flow_dump(" auth: ", ctx->authkey, ctx->authkeylen);
> +
> + /* setkey the fallback just in case we needto use it */
> + if (ctx->fallback_cipher) {
> + flow_log(" running fallback setkey()\n");
> +
> + ctx->fallback_cipher->base.crt_flags &= ~CRYPTO_TFM_REQ_MASK;
> + ctx->fallback_cipher->base.crt_flags |=
> + tfm->crt_flags & CRYPTO_TFM_REQ_MASK;
> + ret =
> + crypto_aead_setkey(ctx->fallback_cipher, origkey,
> + origkeylen);
> + if (ret) {
> + flow_log(" fallback setkey() returned:%d\n", ret);
> + tfm->crt_flags &= ~CRYPTO_TFM_RES_MASK;
> + tfm->crt_flags |=
> + (ctx->fallback_cipher->
> + base.crt_flags & CRYPTO_TFM_RES_MASK);
> + }
> + }
> +
> + ctx->spu_resp_hdr_len = spu->spu_response_hdr_len(ctx->authkeylen,
> + ctx->enckeylen,
> + false);
> +
> + atomic_inc(&iproc_priv.setkey_cnt[SPU_OP_AEAD]);
> +
> + return ret;
> +
> +badkey:
> + ctx->enckeylen = 0;
> + ctx->authkeylen = 0;
> + ctx->digestsize = 0;
> +
> + crypto_aead_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
> + return -EINVAL;
> +}
> +
> +static int aead_gcm_ccm_setkey(struct crypto_aead *cipher,
> + const u8 *key, unsigned int keylen)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct iproc_ctx_s *ctx = crypto_aead_ctx(cipher);
> + struct crypto_tfm *tfm = crypto_aead_tfm(cipher);
> +
> + int ret = 0;
> +
> + flow_log("%s() keylen:%u\n", __func__, keylen);
> + flow_dump(" key: ", key, keylen);
> +
> + if (!ctx->is_esp)
> + ctx->digestsize = keylen;
> +
> + ctx->enckeylen = keylen;
> + ctx->authkeylen = 0;
> + memcpy(ctx->enckey, key, ctx->enckeylen);
> +
> + switch (ctx->enckeylen) {
> + case AES_KEYSIZE_128:
> + ctx->cipher_type = CIPHER_TYPE_AES128;
> + break;
> + case AES_KEYSIZE_192:
> + ctx->cipher_type = CIPHER_TYPE_AES192;
> + break;
> + case AES_KEYSIZE_256:
> + ctx->cipher_type = CIPHER_TYPE_AES256;
> + break;
> + default:
> + goto badkey;
> + }
> +
> + flow_log(" enckeylen:%u authkeylen:%u\n", ctx->enckeylen,
> + ctx->authkeylen);
> + flow_dump(" enc: ", ctx->enckey, ctx->enckeylen);
> + flow_dump(" auth: ", ctx->authkey, ctx->authkeylen);
> +
> + /* setkey the fallback just in case we need to use it */
> + if (ctx->fallback_cipher) {
> + flow_log(" running fallback setkey()\n");
> +
> + ctx->fallback_cipher->base.crt_flags &= ~CRYPTO_TFM_REQ_MASK;
> + ctx->fallback_cipher->base.crt_flags |=
> + tfm->crt_flags & CRYPTO_TFM_REQ_MASK;
> + ret = crypto_aead_setkey(ctx->fallback_cipher, key,
> + keylen + ctx->salt_len);
> + if (ret) {
> + flow_log(" fallback setkey() returned:%d\n", ret);
> + tfm->crt_flags &= ~CRYPTO_TFM_RES_MASK;
> + tfm->crt_flags |=
> + (ctx->fallback_cipher->
> + base.crt_flags & CRYPTO_TFM_RES_MASK);
> + }
> + }
> +
> + ctx->spu_resp_hdr_len = spu->spu_response_hdr_len(ctx->authkeylen,
> + ctx->enckeylen,
> + false);
> +
> + atomic_inc(&iproc_priv.setkey_cnt[SPU_OP_AEAD]);
> +
> + flow_log(" enckeylen:%u authkeylen:%u\n", ctx->enckeylen,
> + ctx->authkeylen);
> +
> + return ret;
> +
> +badkey:
> + ctx->enckeylen = 0;
> + ctx->authkeylen = 0;
> + ctx->digestsize = 0;
> +
> + crypto_aead_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
> + return -EINVAL;
> +}
> +
> +/**
> + * aead_gcm_esp_setkey() - setkey() operation for ESP variant of GCM AES.
> + * @cipher: AEAD structure
> + * @key: Key followed by 4 bytes of salt
> + * @keylen: Length of key plus salt, in bytes
> + *
> + * Extracts salt from key and stores it to be prepended to IV on each request.
> + * Digest is always 16 bytes
> + *
> + * Return: Value from generic gcm setkey.
> + */
> +static int aead_gcm_esp_setkey(struct crypto_aead *cipher,
> + const u8 *key, unsigned int keylen)
> +{
> + struct iproc_ctx_s *ctx = crypto_aead_ctx(cipher);
> +
> + flow_log("%s\n", __func__);
> + ctx->salt_len = GCM_ESP_SALT_SIZE;
> + ctx->salt_offset = GCM_ESP_SALT_OFFSET;
> + memcpy(ctx->salt, key + keylen - GCM_ESP_SALT_SIZE, GCM_ESP_SALT_SIZE);
> + keylen -= GCM_ESP_SALT_SIZE;
> + ctx->digestsize = GCM_ESP_DIGESTSIZE;
> + ctx->is_esp = true;
> + flow_dump("salt: ", ctx->salt, GCM_ESP_SALT_SIZE);
> +
> + return aead_gcm_ccm_setkey(cipher, key, keylen);
> +}
> +
> +/**
> + * rfc4543_gcm_esp_setkey() - setkey operation for RFC4543 variant of GCM/GMAC.
> + * cipher: AEAD structure
> + * key: Key followed by 4 bytes of salt
> + * keylen: Length of key plus salt, in bytes
> + *
> + * Extracts salt from key and stores it to be prepended to IV on each request.
> + * Digest is always 16 bytes
> + *
> + * Return: Value from generic gcm setkey.
> + */
> +static int rfc4543_gcm_esp_setkey(struct crypto_aead *cipher,
> + const u8 *key, unsigned int keylen)
> +{
> + struct iproc_ctx_s *ctx = crypto_aead_ctx(cipher);
> +
> + flow_log("%s\n", __func__);
> + ctx->salt_len = GCM_ESP_SALT_SIZE;
> + ctx->salt_offset = GCM_ESP_SALT_OFFSET;
> + memcpy(ctx->salt, key + keylen - GCM_ESP_SALT_SIZE, GCM_ESP_SALT_SIZE);
> + keylen -= GCM_ESP_SALT_SIZE;
> + ctx->digestsize = GCM_ESP_DIGESTSIZE;
> + ctx->is_esp = true;
> + ctx->is_rfc4543 = true;
> + flow_dump("salt: ", ctx->salt, GCM_ESP_SALT_SIZE);
> +
> + return aead_gcm_ccm_setkey(cipher, key, keylen);
> +}
> +
> +/**
> + * aead_ccm_esp_setkey() - setkey() operation for ESP variant of CCM AES.
> + * @cipher: AEAD structure
> + * @key: Key followed by 4 bytes of salt
> + * @keylen: Length of key plus salt, in bytes
> + *
> + * Extracts salt from key and stores it to be prepended to IV on each request.
> + * Digest is always 16 bytes
> + *
> + * Return: Value from generic ccm setkey.
> + */
> +static int aead_ccm_esp_setkey(struct crypto_aead *cipher,
> + const u8 *key, unsigned int keylen)
> +{
> + struct iproc_ctx_s *ctx = crypto_aead_ctx(cipher);
> +
> + flow_log("%s\n", __func__);
> + ctx->salt_len = CCM_ESP_SALT_SIZE;
> + ctx->salt_offset = CCM_ESP_SALT_OFFSET;
> + memcpy(ctx->salt, key + keylen - CCM_ESP_SALT_SIZE, CCM_ESP_SALT_SIZE);
> + keylen -= CCM_ESP_SALT_SIZE;
> + ctx->is_esp = true;
> + flow_dump("salt: ", ctx->salt, CCM_ESP_SALT_SIZE);
> +
> + return aead_gcm_ccm_setkey(cipher, key, keylen);
> +}
> +
> +static int aead_setauthsize(struct crypto_aead *cipher, unsigned int authsize)
> +{
> + struct iproc_ctx_s *ctx = crypto_aead_ctx(cipher);
> + int ret = 0;
> +
> + flow_log("%s() authkeylen:%u authsize:%u\n",
> + __func__, ctx->authkeylen, authsize);
> +
> + ctx->digestsize = authsize;
> +
> + /* setkey the fallback just in case we needto use it */
> + if (ctx->fallback_cipher) {
> + flow_log(" running fallback setauth()\n");
> +
> + ret = crypto_aead_setauthsize(ctx->fallback_cipher, authsize);
> + if (ret)
> + flow_log(" fallback setauth() returned:%d\n", ret);
> + }
> +
> + return ret;
> +}
> +
> +static int aead_encrypt(struct aead_request *req)
> +{
> + flow_log("%s() cryptlen:%u %08x\n", __func__, req->cryptlen,
> + req->cryptlen);
> + dump_sg(req->src, 0, req->cryptlen + req->assoclen);
> + flow_log(" assoc_len:%u\n", req->assoclen);
> +
> + return aead_enqueue(req, true);
> +}
> +
> +static int aead_decrypt(struct aead_request *req)
> +{
> + flow_log("%s() cryptlen:%u\n", __func__, req->cryptlen);
> + dump_sg(req->src, 0, req->cryptlen + req->assoclen);
> + flow_log(" assoc_len:%u\n", req->assoclen);
> +
> + return aead_enqueue(req, false);
> +}
> +
> +/* ==================== Supported Cipher Algorithms ==================== */
> +
> +static struct iproc_alg_s driver_algs[] = {
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "gcm(aes)",
> + .cra_driver_name = "gcm-aes-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK
> + },
> + .setkey = aead_gcm_ccm_setkey,
> + .ivsize = GCM_AES_IV_SIZE,
> + .maxauthsize = AES_BLOCK_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_AES,
> + .mode = CIPHER_MODE_GCM,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_AES,
> + .mode = HASH_MODE_GCM,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "ccm(aes)",
> + .cra_driver_name = "ccm-aes-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK
> + },
> + .setkey = aead_gcm_ccm_setkey,
> + .ivsize = CCM_AES_IV_SIZE,
> + .maxauthsize = AES_BLOCK_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_AES,
> + .mode = CIPHER_MODE_CCM,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_AES,
> + .mode = HASH_MODE_CCM,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "rfc4106(gcm(aes))",
> + .cra_driver_name = "gcm-aes-esp-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK
> + },
> + .setkey = aead_gcm_esp_setkey,
> + .ivsize = GCM_ESP_IV_SIZE,
> + .maxauthsize = AES_BLOCK_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_AES,
> + .mode = CIPHER_MODE_GCM,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_AES,
> + .mode = HASH_MODE_GCM,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "rfc4309(ccm(aes))",
> + .cra_driver_name = "ccm-aes-esp-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK
> + },
> + .setkey = aead_ccm_esp_setkey,
> + .ivsize = CCM_AES_IV_SIZE,
> + .maxauthsize = AES_BLOCK_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_AES,
> + .mode = CIPHER_MODE_CCM,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_AES,
> + .mode = HASH_MODE_CCM,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "rfc4543(gcm(aes))",
> + .cra_driver_name = "gmac-aes-esp-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK
> + },
> + .setkey = rfc4543_gcm_esp_setkey,
> + .ivsize = GCM_ESP_IV_SIZE,
> + .maxauthsize = AES_BLOCK_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_AES,
> + .mode = CIPHER_MODE_GCM,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_AES,
> + .mode = HASH_MODE_GCM,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(md5),cbc(aes))",
> + .cra_driver_name = "authenc-hmac-md5-cbc-aes-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = AES_BLOCK_SIZE,
> + .maxauthsize = MD5_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_AES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_MD5,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(sha1),cbc(aes))",
> + .cra_driver_name = "authenc-hmac-sha1-cbc-aes-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = AES_BLOCK_SIZE,
> + .maxauthsize = SHA1_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_AES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA1,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(sha256),cbc(aes))",
> + .cra_driver_name = "authenc-hmac-sha256-cbc-aes-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = AES_BLOCK_SIZE,
> + .maxauthsize = SHA256_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_AES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA256,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(md5),cbc(des))",
> + .cra_driver_name = "authenc-hmac-md5-cbc-des-iproc",
> + .cra_blocksize = DES_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = DES_BLOCK_SIZE,
> + .maxauthsize = MD5_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_DES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_MD5,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(sha1),cbc(des))",
> + .cra_driver_name = "authenc-hmac-sha1-cbc-des-iproc",
> + .cra_blocksize = DES_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = DES_BLOCK_SIZE,
> + .maxauthsize = SHA1_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_DES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA1,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(sha224),cbc(des))",
> + .cra_driver_name = "authenc-hmac-sha224-cbc-des-iproc",
> + .cra_blocksize = DES_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = DES_BLOCK_SIZE,
> + .maxauthsize = SHA224_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_DES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA224,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(sha256),cbc(des))",
> + .cra_driver_name = "authenc-hmac-sha256-cbc-des-iproc",
> + .cra_blocksize = DES_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = DES_BLOCK_SIZE,
> + .maxauthsize = SHA256_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_DES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA256,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(sha384),cbc(des))",
> + .cra_driver_name = "authenc-hmac-sha384-cbc-des-iproc",
> + .cra_blocksize = DES_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = DES_BLOCK_SIZE,
> + .maxauthsize = SHA384_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_DES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA384,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(sha512),cbc(des))",
> + .cra_driver_name = "authenc-hmac-sha512-cbc-des-iproc",
> + .cra_blocksize = DES_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = DES_BLOCK_SIZE,
> + .maxauthsize = SHA512_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_DES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA512,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(md5),cbc(des3_ede))",
> + .cra_driver_name = "authenc-hmac-md5-cbc-des3-iproc",
> + .cra_blocksize = DES3_EDE_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = DES3_EDE_BLOCK_SIZE,
> + .maxauthsize = MD5_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_3DES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_MD5,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(sha1),cbc(des3_ede))",
> + .cra_driver_name = "authenc-hmac-sha1-cbc-des3-iproc",
> + .cra_blocksize = DES3_EDE_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = DES3_EDE_BLOCK_SIZE,
> + .maxauthsize = SHA1_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_3DES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA1,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(sha224),cbc(des3_ede))",
> + .cra_driver_name = "authenc-hmac-sha224-cbc-des3-iproc",
> + .cra_blocksize = DES3_EDE_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = DES3_EDE_BLOCK_SIZE,
> + .maxauthsize = SHA224_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_3DES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA224,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(sha256),cbc(des3_ede))",
> + .cra_driver_name = "authenc-hmac-sha256-cbc-des3-iproc",
> + .cra_blocksize = DES3_EDE_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = DES3_EDE_BLOCK_SIZE,
> + .maxauthsize = SHA256_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_3DES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA256,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(sha384),cbc(des3_ede))",
> + .cra_driver_name = "authenc-hmac-sha384-cbc-des3-iproc",
> + .cra_blocksize = DES3_EDE_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = DES3_EDE_BLOCK_SIZE,
> + .maxauthsize = SHA384_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_3DES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA384,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AEAD,
> + .alg.aead = {
> + .base = {
> + .cra_name = "authenc(hmac(sha512),cbc(des3_ede))",
> + .cra_driver_name = "authenc-hmac-sha512-cbc-des3-iproc",
> + .cra_blocksize = DES3_EDE_BLOCK_SIZE,
> + .cra_flags = CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC
> + },
> + .setkey = aead_authenc_setkey,
> + .ivsize = DES3_EDE_BLOCK_SIZE,
> + .maxauthsize = SHA512_DIGEST_SIZE,
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_3DES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA512,
> + .mode = HASH_MODE_HMAC,
> + },
> + .auth_first = 0,
> + },
> +
> +/* ABLKCIPHER algorithms. */
> + {
> + .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> + .alg.crypto = {
> + .cra_name = "ecb(arc4)",
> + .cra_driver_name = "ecb-arc4-iproc",
> + .cra_blocksize = ARC4_BLOCK_SIZE,
> + .cra_ablkcipher = {
> + .min_keysize = ARC4_MIN_KEY_SIZE,
> + .max_keysize = ARC4_MAX_KEY_SIZE,
> + .ivsize = 0,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_RC4,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_NONE,
> + .mode = HASH_MODE_NONE,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> + .alg.crypto = {
> + .cra_name = "ofb(des)",
> + .cra_driver_name = "ofb-des-iproc",
> + .cra_blocksize = DES_BLOCK_SIZE,
> + .cra_ablkcipher = {
> + .min_keysize = DES_KEY_SIZE,
> + .max_keysize = DES_KEY_SIZE,
> + .ivsize = DES_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_DES,
> + .mode = CIPHER_MODE_OFB,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_NONE,
> + .mode = HASH_MODE_NONE,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> + .alg.crypto = {
> + .cra_name = "cbc(des)",
> + .cra_driver_name = "cbc-des-iproc",
> + .cra_blocksize = DES_BLOCK_SIZE,
> + .cra_ablkcipher = {
> + .min_keysize = DES_KEY_SIZE,
> + .max_keysize = DES_KEY_SIZE,
> + .ivsize = DES_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_DES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_NONE,
> + .mode = HASH_MODE_NONE,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> + .alg.crypto = {
> + .cra_name = "ecb(des)",
> + .cra_driver_name = "ecb-des-iproc",
> + .cra_blocksize = DES_BLOCK_SIZE,
> + .cra_ablkcipher = {
> + .min_keysize = DES_KEY_SIZE,
> + .max_keysize = DES_KEY_SIZE,
> + .ivsize = 0,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_DES,
> + .mode = CIPHER_MODE_ECB,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_NONE,
> + .mode = HASH_MODE_NONE,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> + .alg.crypto = {
> + .cra_name = "ofb(des3_ede)",
> + .cra_driver_name = "ofb-des3-iproc",
> + .cra_blocksize = DES3_EDE_BLOCK_SIZE,
> + .cra_ablkcipher = {
> + .min_keysize = DES3_EDE_KEY_SIZE,
> + .max_keysize = DES3_EDE_KEY_SIZE,
> + .ivsize = DES3_EDE_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_3DES,
> + .mode = CIPHER_MODE_OFB,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_NONE,
> + .mode = HASH_MODE_NONE,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> + .alg.crypto = {
> + .cra_name = "cbc(des3_ede)",
> + .cra_driver_name = "cbc-des3-iproc",
> + .cra_blocksize = DES3_EDE_BLOCK_SIZE,
> + .cra_ablkcipher = {
> + .min_keysize = DES3_EDE_KEY_SIZE,
> + .max_keysize = DES3_EDE_KEY_SIZE,
> + .ivsize = DES3_EDE_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_3DES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_NONE,
> + .mode = HASH_MODE_NONE,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> + .alg.crypto = {
> + .cra_name = "ecb(des3_ede)",
> + .cra_driver_name = "ecb-des3-iproc",
> + .cra_blocksize = DES3_EDE_BLOCK_SIZE,
> + .cra_ablkcipher = {
> + .min_keysize = DES3_EDE_KEY_SIZE,
> + .max_keysize = DES3_EDE_KEY_SIZE,
> + .ivsize = 0,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_3DES,
> + .mode = CIPHER_MODE_ECB,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_NONE,
> + .mode = HASH_MODE_NONE,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> + .alg.crypto = {
> + .cra_name = "ofb(aes)",
> + .cra_driver_name = "ofb-aes-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + .cra_ablkcipher = {
> + .min_keysize = AES_MIN_KEY_SIZE,
> + .max_keysize = AES_MAX_KEY_SIZE,
> + .ivsize = AES_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_AES,
> + .mode = CIPHER_MODE_OFB,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_NONE,
> + .mode = HASH_MODE_NONE,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> + .alg.crypto = {
> + .cra_name = "cbc(aes)",
> + .cra_driver_name = "cbc-aes-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + .cra_ablkcipher = {
> + .min_keysize = AES_MIN_KEY_SIZE,
> + .max_keysize = AES_MAX_KEY_SIZE,
> + .ivsize = AES_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_AES,
> + .mode = CIPHER_MODE_CBC,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_NONE,
> + .mode = HASH_MODE_NONE,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> + .alg.crypto = {
> + .cra_name = "ecb(aes)",
> + .cra_driver_name = "ecb-aes-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + .cra_ablkcipher = {
> + .min_keysize = AES_MIN_KEY_SIZE,
> + .max_keysize = AES_MAX_KEY_SIZE,
> + .ivsize = 0,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_AES,
> + .mode = CIPHER_MODE_ECB,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_NONE,
> + .mode = HASH_MODE_NONE,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> + .alg.crypto = {
> + .cra_name = "ctr(aes)",
> + .cra_driver_name = "ctr-aes-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + .cra_ablkcipher = {
> + /* .geniv = "chainiv", */
> + .min_keysize = AES_MIN_KEY_SIZE,
> + .max_keysize = AES_MAX_KEY_SIZE,
> + .ivsize = AES_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_AES,
> + .mode = CIPHER_MODE_CTR,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_NONE,
> + .mode = HASH_MODE_NONE,
> + },
> + },
> +{
> + .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> + .alg.crypto = {
> + .cra_name = "xts(aes)",
> + .cra_driver_name = "xts-aes-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + .cra_ablkcipher = {
> + .min_keysize = 2 * AES_MIN_KEY_SIZE,
> + .max_keysize = 2 * AES_MAX_KEY_SIZE,
> + .ivsize = AES_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_AES,
> + .mode = CIPHER_MODE_XTS,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_NONE,
> + .mode = HASH_MODE_NONE,
> + },
> + },
> +
> +/* AHASH algorithms. */
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = MD5_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "md5",
> + .cra_driver_name = "md5-iproc",
> + .cra_blocksize = MD5_BLOCK_WORDS * 4,
> + .cra_flags = CRYPTO_ALG_TYPE_AHASH |
> + CRYPTO_ALG_ASYNC,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_MD5,
> + .mode = HASH_MODE_HASH,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = MD5_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "hmac(md5)",
> + .cra_driver_name = "hmac-md5-iproc",
> + .cra_blocksize = MD5_BLOCK_WORDS * 4,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_MD5,
> + .mode = HASH_MODE_HMAC,
> + },
> + },
> + {.type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA1_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "sha1",
> + .cra_driver_name = "sha1-iproc",
> + .cra_blocksize = SHA1_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA1,
> + .mode = HASH_MODE_HASH,
> + },
> + },
> + {.type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA1_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "hmac(sha1)",
> + .cra_driver_name = "hmac-sha1-iproc",
> + .cra_blocksize = SHA1_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA1,
> + .mode = HASH_MODE_HMAC,
> + },
> + },
> + {.type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA224_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "sha224",
> + .cra_driver_name = "sha224-iproc",
> + .cra_blocksize = SHA224_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA224,
> + .mode = HASH_MODE_HASH,
> + },
> + },
> + {.type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA224_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "hmac(sha224)",
> + .cra_driver_name = "hmac-sha224-iproc",
> + .cra_blocksize = SHA224_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA224,
> + .mode = HASH_MODE_HMAC,
> + },
> + },
> + {.type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA256_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "sha256",
> + .cra_driver_name = "sha256-iproc",
> + .cra_blocksize = SHA256_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA256,
> + .mode = HASH_MODE_HASH,
> + },
> + },
> + {.type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA256_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "hmac(sha256)",
> + .cra_driver_name = "hmac-sha256-iproc",
> + .cra_blocksize = SHA256_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA256,
> + .mode = HASH_MODE_HMAC,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA384_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "sha384",
> + .cra_driver_name = "sha384-iproc",
> + .cra_blocksize = SHA384_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA384,
> + .mode = HASH_MODE_HASH,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA384_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "hmac(sha384)",
> + .cra_driver_name = "hmac-sha384-iproc",
> + .cra_blocksize = SHA384_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA384,
> + .mode = HASH_MODE_HMAC,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA512_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "sha512",
> + .cra_driver_name = "sha512-iproc",
> + .cra_blocksize = SHA512_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA512,
> + .mode = HASH_MODE_HASH,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA512_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "hmac(sha512)",
> + .cra_driver_name = "hmac-sha512-iproc",
> + .cra_blocksize = SHA512_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA512,
> + .mode = HASH_MODE_HMAC,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA3_224_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "sha3-224",
> + .cra_driver_name = "sha3-224-iproc",
> + .cra_blocksize = SHA3_224_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA3_224,
> + .mode = HASH_MODE_HASH,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA3_224_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "hmac(sha3-224)",
> + .cra_driver_name = "hmac-sha3-224-iproc",
> + .cra_blocksize = SHA3_224_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA3_224,
> + .mode = HASH_MODE_HMAC
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA3_256_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "sha3-256",
> + .cra_driver_name = "sha3-256-iproc",
> + .cra_blocksize = SHA3_256_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA3_256,
> + .mode = HASH_MODE_HASH,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA3_256_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "hmac(sha3-256)",
> + .cra_driver_name = "hmac-sha3-256-iproc",
> + .cra_blocksize = SHA3_256_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA3_256,
> + .mode = HASH_MODE_HMAC,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA3_384_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "sha3-384",
> + .cra_driver_name = "sha3-384-iproc",
> + .cra_blocksize = SHA3_224_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA3_384,
> + .mode = HASH_MODE_HASH,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA3_384_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "hmac(sha3-384)",
> + .cra_driver_name = "hmac-sha3-384-iproc",
> + .cra_blocksize = SHA3_384_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA3_384,
> + .mode = HASH_MODE_HMAC,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA3_512_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "sha3-512",
> + .cra_driver_name = "sha3-512-iproc",
> + .cra_blocksize = SHA3_512_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA3_512,
> + .mode = HASH_MODE_HASH,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = SHA3_512_DIGEST_SIZE,
> + .halg.base = {
> + .cra_name = "hmac(sha3-512)",
> + .cra_driver_name = "hmac-sha3-512-iproc",
> + .cra_blocksize = SHA3_512_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_SHA3_512,
> + .mode = HASH_MODE_HMAC,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = AES_BLOCK_SIZE,
> + .halg.base = {
> + .cra_name = "xcbc(aes)",
> + .cra_driver_name = "xcbc-aes-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_AES,
> + .mode = HASH_MODE_XCBC,
> + },
> + },
> + {
> + .type = CRYPTO_ALG_TYPE_AHASH,
> + .alg.hash = {
> + .halg.digestsize = AES_BLOCK_SIZE,
> + .halg.base = {
> + .cra_name = "cmac(aes)",
> + .cra_driver_name = "cmac-aes-iproc",
> + .cra_blocksize = AES_BLOCK_SIZE,
> + }
> + },
> + .cipher_info = {
> + .alg = CIPHER_ALG_NONE,
> + .mode = CIPHER_MODE_NONE,
> + },
> + .auth_info = {
> + .alg = HASH_ALG_AES,
> + .mode = HASH_MODE_CMAC,
> + },
> + },
> +};
> +
> +static int generic_cra_init(struct crypto_tfm *tfm,
> + struct iproc_alg_s *cipher_alg)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct iproc_ctx_s *ctx = crypto_tfm_ctx(tfm);
> + unsigned int blocksize = crypto_tfm_alg_blocksize(tfm);
> +
> + flow_log("%s()\n", __func__);
> +
> + ctx->alg = cipher_alg;
> + ctx->cipher = cipher_alg->cipher_info;
> + ctx->auth = cipher_alg->auth_info;
> + ctx->auth_first = cipher_alg->auth_first;
> + ctx->max_payload = spu->spu_ctx_max_payload(ctx->cipher.alg,
> + ctx->cipher.mode,
> + blocksize);
> + ctx->fallback_cipher = NULL;
> +
> + ctx->enckeylen = 0;
> + ctx->authkeylen = 0;
> +
> + atomic_inc(&iproc_priv.stream_count);
> + atomic_inc(&iproc_priv.session_count);
> +
> + return 0;
> +}
> +
> +static int ablkcipher_cra_init(struct crypto_tfm *tfm)
> +{
> + struct crypto_alg *alg = tfm->__crt_alg;
> + struct iproc_alg_s *cipher_alg;
> +
> + flow_log("%s()\n", __func__);
> +
> + tfm->crt_ablkcipher.reqsize = sizeof(struct iproc_reqctx_s);
> +
> + cipher_alg = container_of(alg, struct iproc_alg_s, alg.crypto);
> + return generic_cra_init(tfm, cipher_alg);
> +}
> +
> +static int ahash_cra_init(struct crypto_tfm *tfm)
> +{
> + int err;
> + struct crypto_alg *alg = tfm->__crt_alg;
> + struct iproc_alg_s *cipher_alg;
> +
> + cipher_alg = container_of(__crypto_ahash_alg(alg), struct iproc_alg_s,
> + alg.hash);
> +
> + err = generic_cra_init(tfm, cipher_alg);
> + flow_log("%s()\n", __func__);
> +
> + /*
> + * export state size has to be < 512 bytes. So don't include msg bufs
> + * in state size.
> + */
> + crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
> + sizeof(struct iproc_reqctx_s));
> +
> + return err;
> +}
> +
> +static int aead_cra_init(struct crypto_aead *aead)
> +{
> + struct crypto_tfm *tfm = crypto_aead_tfm(aead);
> + struct iproc_ctx_s *ctx = crypto_tfm_ctx(tfm);
> + struct crypto_alg *alg = tfm->__crt_alg;
> + struct aead_alg *aalg = container_of(alg, struct aead_alg, base);
> + struct iproc_alg_s *cipher_alg = container_of(aalg, struct iproc_alg_s,
> + alg.aead);
> +
> + int err = generic_cra_init(tfm, cipher_alg);
> +
> + flow_log("%s()\n", __func__);
> +
> + crypto_aead_set_reqsize(aead, sizeof(struct iproc_reqctx_s));
> + ctx->is_esp = false;
> + ctx->salt_len = 0;
> + ctx->salt_offset = 0;
> +
> + /* random first IV */
> + get_random_bytes(ctx->iv, MAX_IV_SIZE);
> + flow_dump(" iv: ", ctx->iv, MAX_IV_SIZE);
> +
> + if (!err) {
> + if (alg->cra_flags & CRYPTO_ALG_NEED_FALLBACK) {
> + flow_log("%s() creating fallback cipher\n", __func__);
> +
> + ctx->fallback_cipher =
> + crypto_alloc_aead(alg->cra_name, 0,
> + CRYPTO_ALG_ASYNC |
> + CRYPTO_ALG_NEED_FALLBACK);
> + if (IS_ERR(ctx->fallback_cipher)) {
> + pr_err("%s() Error: failed to allocate fallback for %s\n",
> + __func__, alg->cra_name);
> + return PTR_ERR(ctx->fallback_cipher);
> + }
> + }
> + }
> +
> + return err;
> +}
> +
> +static void generic_cra_exit(struct crypto_tfm *tfm)
> +{
> + atomic_dec(&iproc_priv.session_count);
> +}
> +
> +static void aead_cra_exit(struct crypto_aead *aead)
> +{
> + struct crypto_tfm *tfm = crypto_aead_tfm(aead);
> + struct iproc_ctx_s *ctx = crypto_tfm_ctx(tfm);
> +
> + generic_cra_exit(tfm);
> +
> + if (ctx->fallback_cipher) {
> + crypto_free_aead(ctx->fallback_cipher);
> + ctx->fallback_cipher = NULL;
> + }
> +}
> +
> +/**
> + * spu_functions_register() - Specify hardware-specific SPU functions based on
> + * SPU type read from device tree.
> + * @dev: device structure
> + * @spu_type: SPU hardware generation
> + * @spu_subtype: SPU hardware version
> + */
> +static void spu_functions_register(struct device *dev,
> + enum spu_spu_type spu_type,
> + enum spu_spu_subtype spu_subtype)
> +{
> + struct spu_hw *spu = &iproc_priv.spu;
> +
> + if (spu_type == SPU_TYPE_SPUM) {
> + dev_dbg(dev, "Registering SPUM functions");
> + spu->spu_dump_msg_hdr = spum_dump_msg_hdr;
> + spu->spu_payload_length = spum_payload_length;
> + spu->spu_response_hdr_len = spum_response_hdr_len;
> + spu->spu_hash_pad_len = spum_hash_pad_len;
> + spu->spu_gcm_ccm_pad_len = spum_gcm_ccm_pad_len;
> + spu->spu_assoc_resp_len = spum_assoc_resp_len;
> + spu->spu_aead_ivlen = spum_aead_ivlen;
> + spu->spu_hash_type = spum_hash_type;
> + spu->spu_digest_size = spum_digest_size;
> + spu->spu_create_request = spum_create_request;
> + spu->spu_cipher_req_init = spum_cipher_req_init;
> + spu->spu_cipher_req_finish = spum_cipher_req_finish;
> + spu->spu_request_pad = spum_request_pad;
> + spu->spu_tx_status_len = spum_tx_status_len;
> + spu->spu_rx_status_len = spum_rx_status_len;
> + spu->spu_status_process = spum_status_process;
> + spu->spu_xts_tweak_in_payload = spum_xts_tweak_in_payload;
> + spu->spu_ccm_update_iv = spum_ccm_update_iv;
> + spu->spu_wordalign_padlen = spum_wordalign_padlen;
> + if (spu_subtype == SPU_SUBTYPE_SPUM_NS2)
> + spu->spu_ctx_max_payload = spum_ns2_ctx_max_payload;
> + else
> + spu->spu_ctx_max_payload = spum_nsp_ctx_max_payload;
> + } else {
> + dev_dbg(dev, "Registering SPU2 functions");
> + spu->spu_dump_msg_hdr = spu2_dump_msg_hdr;
> + spu->spu_ctx_max_payload = spu2_ctx_max_payload;
> + spu->spu_payload_length = spu2_payload_length;
> + spu->spu_response_hdr_len = spu2_response_hdr_len;
> + spu->spu_hash_pad_len = spu2_hash_pad_len;
> + spu->spu_gcm_ccm_pad_len = spu2_gcm_ccm_pad_len;
> + spu->spu_assoc_resp_len = spu2_assoc_resp_len;
> + spu->spu_aead_ivlen = spu2_aead_ivlen;
> + spu->spu_hash_type = spu2_hash_type;
> + spu->spu_digest_size = spu2_digest_size;
> + spu->spu_create_request = spu2_create_request;
> + spu->spu_cipher_req_init = spu2_cipher_req_init;
> + spu->spu_cipher_req_finish = spu2_cipher_req_finish;
> + spu->spu_request_pad = spu2_request_pad;
> + spu->spu_tx_status_len = spu2_tx_status_len;
> + spu->spu_rx_status_len = spu2_rx_status_len;
> + spu->spu_status_process = spu2_status_process;
> + spu->spu_xts_tweak_in_payload = spu2_xts_tweak_in_payload;
> + spu->spu_ccm_update_iv = spu2_ccm_update_iv;
> + spu->spu_wordalign_padlen = spu2_wordalign_padlen;
> + }
> +}
> +
> +/**
> + * spu_mb_init() - Initialize mailbox client. Request ownership of each mailbox
> + * channel in the device tree.
> + * @dev: SPU driver device structure
> + *
> + * Return: 0 if successful
> + * < 0 otherwise
> + */
> +static int spu_mb_init(struct device *dev)
> +{
> + int i;
> + struct mbox_client *mcl = &iproc_priv.mcl;
> + int err;
> +
> + iproc_priv.mbox = kcalloc(iproc_priv.spu.num_chan,
> + sizeof(struct mbox_chan *), GFP_KERNEL);
> + if (!iproc_priv.mbox)
> + return -ENOMEM;
> +
> + mcl->dev = dev;
> + mcl->tx_block = false;
> + mcl->tx_tout = 0;
> + mcl->knows_txdone = false;
> + mcl->rx_callback = spu_rx_callback;
> + mcl->tx_done = NULL;
> +
> + for (i = 0; i < iproc_priv.spu.num_chan; i++) {
> + iproc_priv.mbox[i] = mbox_request_channel(mcl, i);
> + if (IS_ERR(iproc_priv.mbox[i])) {
> + err = (int)PTR_ERR(iproc_priv.mbox[i]);
> + dev_err(dev,
> + "Mbox channel %d request failed with err %d",
> + i, err);
> + iproc_priv.mbox[i] = NULL;
> + return err;
> + }
> + }
> +
> + return 0;
> +}
> +
> +static void spu_mb_release(struct platform_device *pdev)
> +{
> + int i;
> +
> + if (!iproc_priv.mbox)
> + return;
> +
> + for (i = 0; i < iproc_priv.spu.num_chan; i++)
> + mbox_free_channel(iproc_priv.mbox[i]);
> +
> + kfree(iproc_priv.mbox);
> + iproc_priv.mbox = NULL;
> +}
> +
> +static void spu_counters_init(void)
> +{
> + int i;
> + int j;
> +
> + atomic_set(&iproc_priv.session_count, 0);
> + atomic_set(&iproc_priv.stream_count, 0);
> + atomic_set(&iproc_priv.next_chan, (int)iproc_priv.spu.num_chan);
> + atomic64_set(&iproc_priv.bytes_in, 0);
> + atomic64_set(&iproc_priv.bytes_out, 0);
> + for (i = 0; i < SPU_OP_NUM; i++) {
> + atomic_set(&iproc_priv.op_counts[i], 0);
> + atomic_set(&iproc_priv.setkey_cnt[i], 0);
> + }
> + for (i = 0; i < CIPHER_ALG_LAST; i++)
> + for (j = 0; j < CIPHER_MODE_LAST; j++)
> + atomic_set(&iproc_priv.cipher_cnt[i][j], 0);
> +
> + for (i = 0; i < HASH_ALG_LAST; i++) {
> + atomic_set(&iproc_priv.hash_cnt[i], 0);
> + atomic_set(&iproc_priv.hmac_cnt[i], 0);
> + }
> + for (i = 0; i < AEAD_TYPE_LAST; i++)
> + atomic_set(&iproc_priv.aead_cnt[i], 0);
> +
> + atomic_set(&iproc_priv.mb_no_spc, 0);
> + atomic_set(&iproc_priv.mb_send_fail, 0);
> + atomic_set(&iproc_priv.bad_icv, 0);
> +}
> +
> +static int spu_register_ablkcipher(struct iproc_alg_s *driver_alg)
> +{
> + struct device *dev = &iproc_priv.pdev->dev;
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct crypto_alg *crypto = &driver_alg->alg.crypto;
> + int err;
> +
> + /* SPU2 does not support RC4 */
> + if ((driver_alg->cipher_info.alg == CIPHER_ALG_RC4) &&
> + (spu->spu_type == SPU_TYPE_SPU2))
> + return 0;
> +
> + crypto->cra_module = THIS_MODULE;
> + crypto->cra_priority = cipher_pri;
> + crypto->cra_alignmask = 0;
> + crypto->cra_ctxsize = sizeof(struct iproc_ctx_s);
> + INIT_LIST_HEAD(&crypto->cra_list);
> +
> + crypto->cra_init = ablkcipher_cra_init;
> + crypto->cra_exit = generic_cra_exit;
> + crypto->cra_type = &crypto_ablkcipher_type;
> + crypto->cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC |
> + CRYPTO_ALG_KERN_DRIVER_ONLY;
> +
> + crypto->cra_ablkcipher.setkey = ablkcipher_setkey;
> + crypto->cra_ablkcipher.encrypt = ablkcipher_encrypt;
> + crypto->cra_ablkcipher.decrypt = ablkcipher_decrypt;
> +
> + err = crypto_register_alg(crypto);
> + /* Mark alg as having been registered, if successful */
> + if (err == 0)
> + driver_alg->registered = true;
> + dev_dbg(dev, " registered ablkcipher %s\n", crypto->cra_driver_name);
> + return err;
> +}
> +
> +static int spu_register_ahash(struct iproc_alg_s *driver_alg)
> +{
> + struct device *dev = &iproc_priv.pdev->dev;
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct ahash_alg *hash = &driver_alg->alg.hash;
> + int err;
> +
> + /* AES-XCBC is the only AES hash type currently supported on SPU-M */
> + if ((driver_alg->auth_info.alg == HASH_ALG_AES) &&
> + (driver_alg->auth_info.mode != HASH_MODE_XCBC) &&
> + (spu->spu_type == SPU_TYPE_SPUM))
> + return 0;
> +
> + /* SHA3 algorithm variants are not registered for SPU-M or SPU2. */
> + if ((driver_alg->auth_info.alg >= HASH_ALG_SHA3_224) &&
> + (spu->spu_subtype != SPU_SUBTYPE_SPU2_V2))
> + return 0;
> +
> + hash->halg.base.cra_module = THIS_MODULE;
> + hash->halg.base.cra_priority = hash_pri;
> + hash->halg.base.cra_alignmask = 0;
> + hash->halg.base.cra_ctxsize = sizeof(struct iproc_ctx_s);
> + hash->halg.base.cra_init = ahash_cra_init;
> + hash->halg.base.cra_exit = generic_cra_exit;
> + hash->halg.base.cra_type = &crypto_ahash_type;
> + hash->halg.base.cra_flags = CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC;
> + /*
> + * export state size has to be < 512 bytes. So don't include msg bufs
> + * in state size.
> + */
> + hash->halg.statesize = offsetof(struct iproc_reqctx_s, msg_buf);
> +
> + if (driver_alg->auth_info.mode != HASH_MODE_HMAC) {
> + hash->setkey = ahash_setkey;
> + hash->init = ahash_init;
> + hash->update = ahash_update;
> + hash->final = ahash_final;
> + hash->finup = ahash_finup;
> + hash->digest = ahash_digest;
> + } else {
> + hash->setkey = ahash_hmac_setkey;
> + hash->init = ahash_hmac_init;
> + hash->update = ahash_hmac_update;
> + hash->final = ahash_hmac_final;
> + hash->finup = ahash_hmac_finup;
> + hash->digest = ahash_hmac_digest;
> + }
> + hash->export = ahash_export;
> + hash->import = ahash_import;
> +
> + err = crypto_register_ahash(hash);
> + /* Mark alg as having been registered, if successful */
> + if (err == 0)
> + driver_alg->registered = true;
> + dev_dbg(dev, " registered ahash %s\n",
> + hash->halg.base.cra_driver_name);
> + return err;
> +}
> +
> +static int spu_register_aead(struct iproc_alg_s *driver_alg)
> +{
> + struct device *dev = &iproc_priv.pdev->dev;
> + struct aead_alg *aead = &driver_alg->alg.aead;
> + int err;
> +
> + aead->base.cra_module = THIS_MODULE;
> + aead->base.cra_priority = aead_pri;
> + aead->base.cra_alignmask = 0;
> + aead->base.cra_ctxsize = sizeof(struct iproc_ctx_s);
> + INIT_LIST_HEAD(&aead->base.cra_list);
> +
> + aead->base.cra_flags |= CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC;
> + /* setkey set in alg initialization */
> + aead->setauthsize = aead_setauthsize;
> + aead->encrypt = aead_encrypt;
> + aead->decrypt = aead_decrypt;
> + aead->init = aead_cra_init;
> + aead->exit = aead_cra_exit;
> +
> + err = crypto_register_aead(aead);
> + /* Mark alg as having been registered, if successful */
> + if (err == 0)
> + driver_alg->registered = true;
> + dev_dbg(dev, " registered aead %s\n", aead->base.cra_driver_name);
> + return err;
> +}
> +
> +/* register crypto algorithms the device supports */
> +static int spu_algs_register(struct device *dev)
> +{
> + int i, j;
> + int err;
> +
> + for (i = 0; i < ARRAY_SIZE(driver_algs); i++) {
> + switch (driver_algs[i].type) {
> + case CRYPTO_ALG_TYPE_ABLKCIPHER:
> + err = spu_register_ablkcipher(&driver_algs[i]);
> + break;
> + case CRYPTO_ALG_TYPE_AHASH:
> + err = spu_register_ahash(&driver_algs[i]);
> + break;
> + case CRYPTO_ALG_TYPE_AEAD:
> + err = spu_register_aead(&driver_algs[i]);
> + break;
> + default:
> + dev_err(dev,
> + "iproc-crypto: unknown alg type: %d",
> + driver_algs[i].type);
> + err = -EINVAL;
> + }
> +
> + if (err) {
> + dev_err(dev, "alg registration failed with error %d\n",
> + err);
> + goto err_algs;
> + }
> + }
> +
> + return 0;
> +
> +err_algs:
> + for (j = 0; j < i; j++) {
> + /* Skip any algorithm not registered */
> + if (!driver_algs[j].registered)
> + continue;
> + switch (driver_algs[j].type) {
> + case CRYPTO_ALG_TYPE_ABLKCIPHER:
> + crypto_unregister_alg(&driver_algs[j].alg.crypto);
> + driver_algs[j].registered = false;
> + break;
> + case CRYPTO_ALG_TYPE_AHASH:
> + crypto_unregister_ahash(&driver_algs[j].alg.hash);
> + driver_algs[j].registered = false;
> + break;
> + case CRYPTO_ALG_TYPE_AEAD:
> + crypto_unregister_aead(&driver_algs[j].alg.aead);
> + driver_algs[j].registered = false;
> + break;
> + }
> + }
> + return err;
> +}
> +
> +/* ==================== Kernel Platform API ==================== */
> +
> +static struct spu_type_subtype spum_ns2_types = {
> + SPU_TYPE_SPUM, SPU_SUBTYPE_SPUM_NS2
> +};
> +
> +static struct spu_type_subtype spum_nsp_types = {
> + SPU_TYPE_SPUM, SPU_SUBTYPE_SPUM_NSP
> +};
> +
> +static struct spu_type_subtype spu2_types = {
> + SPU_TYPE_SPU2, SPU_SUBTYPE_SPU2_V1
> +};
> +
> +static struct spu_type_subtype spu2_v2_types = {
> + SPU_TYPE_SPU2, SPU_SUBTYPE_SPU2_V2
> +};
> +
> +static const struct of_device_id bcm_spu_dt_ids[] = {
> + {
> + .compatible = "brcm,spum-crypto",
> + .data = &spum_ns2_types,
> + },
> + {
> + .compatible = "brcm,spum-nsp-crypto",
> + .data = &spum_nsp_types,
> + },
> + {
> + .compatible = "brcm,spu2-crypto",
> + .data = &spu2_types,
> + },
> + {
> + .compatible = "brcm,spu2-v2-crypto",
> + .data = &spu2_v2_types,
> + },
> + { /* sentinel */ }
> +};
> +
> +MODULE_DEVICE_TABLE(of, bcm_spu_dt_ids);
> +
> +static int spu_dt_read(struct platform_device *pdev)
> +{
> + struct device *dev = &pdev->dev;
> + struct spu_hw *spu = &iproc_priv.spu;
> + struct device_node *dn = pdev->dev.of_node;
> + struct resource *spu_ctrl_regs;
> + const struct of_device_id *match;
> + struct spu_type_subtype *matched_spu_type;
> + void __iomem *spu_reg_vbase[MAX_SPUS];
> + int i;
> + int err;
> +
> + if (!of_device_is_available(dn)) {
> + dev_crit(dev, "SPU device not available");
> + return -ENODEV;
> + }
> +
> + /* Count number of mailbox channels */
> + spu->num_chan = of_count_phandle_with_args(dn, "mboxes", "#mbox-cells");
> + dev_dbg(dev, "Device has %d SPU channels", spu->num_chan);
> +
> + match = of_match_device(of_match_ptr(bcm_spu_dt_ids), dev);
> + matched_spu_type = (struct spu_type_subtype *)match->data;
> + spu->spu_type = matched_spu_type->type;
> + spu->spu_subtype = matched_spu_type->subtype;
> +
> + /* Read registers and count number of SPUs */
> + i = 0;
> + while ((i < MAX_SPUS) && ((spu_ctrl_regs =
> + platform_get_resource(pdev, IORESOURCE_MEM, i)) != NULL)) {
> + dev_dbg(dev,
> + "SPU %d control register region res.start = %#x, res.end = %#x",
> + i,
> + (unsigned int)spu_ctrl_regs->start,
> + (unsigned int)spu_ctrl_regs->end);
> +
> + spu_reg_vbase[i] = devm_ioremap_resource(dev, spu_ctrl_regs);
> + if (IS_ERR(spu_reg_vbase[i])) {
> + err = PTR_ERR(spu_reg_vbase[i]);
> + dev_err(&pdev->dev, "Failed to map registers: %d\n",
> + err);
> + spu_reg_vbase[i] = NULL;
> + return err;
> + }
> + i++;
> + }
> + spu->num_spu = i;
> + dev_dbg(dev, "Device has %d SPUs", spu->num_spu);
> +
> + spu->reg_vbase = devm_kcalloc(dev, spu->num_spu,
> + sizeof(*spu->reg_vbase), GFP_KERNEL);
> + if (!spu->reg_vbase)
> + return -ENOMEM;
> + memcpy(spu->reg_vbase, spu_reg_vbase,
> + spu->num_spu * sizeof(*spu->reg_vbase));
> +
> + return 0;
> +}
> +
> +int bcm_spu_probe(struct platform_device *pdev)
> +{
> + struct device *dev = &pdev->dev;
> + struct spu_hw *spu = &iproc_priv.spu;
> + int err = 0;
> +
> + iproc_priv.pdev = pdev;
> + platform_set_drvdata(iproc_priv.pdev, &iproc_priv);
> +
> + err = spu_dt_read(pdev);
> + if (err < 0)
> + goto failure;
> +
> + if (spu->spu_type == SPU_TYPE_SPUM)
> + iproc_priv.bcm_hdr_len = 8;
> + else if (spu->spu_type == SPU_TYPE_SPU2)
> + iproc_priv.bcm_hdr_len = 0;
> +
> + spu_functions_register(&pdev->dev, spu->spu_type, spu->spu_subtype);
> +
> + err = spu_mb_init(&pdev->dev);
> + if (err < 0)
> + goto failure;
> +
> + spu_counters_init();
> +
> + spu_setup_debugfs();
> +
> + err = spu_algs_register(dev);
> + if (err < 0)
> + goto fail_reg;
> +
> + return 0;
> +
> +fail_reg:
> + spu_free_debugfs();
> +failure:
> + spu_mb_release(pdev);
> + dev_err(dev, "%s failed with error %d.\n", __func__, err);
> +
> + return err;
> +}
> +
> +int bcm_spu_remove(struct platform_device *pdev)
> +{
> + int i;
> + struct device *dev = &pdev->dev;
> +
> + for (i = 0; i < ARRAY_SIZE(driver_algs); i++) {
> + /*
> + * Not all algorithms were registered, depending on whether
> + * hardware is SPU or SPU2. So here we make sure to skip
> + * those algorithms that were not previously registered.
> + */
> + if (!driver_algs[i].registered)
> + continue;
> +
> + switch (driver_algs[i].type) {
> + case CRYPTO_ALG_TYPE_ABLKCIPHER:
> + crypto_unregister_alg(&driver_algs[i].alg.crypto);
> + dev_dbg(dev, " unregistered cipher %s\n",
> + driver_algs[i].alg.crypto.cra_driver_name);
> + driver_algs[i].registered = false;
> + break;
> + case CRYPTO_ALG_TYPE_AHASH:
> + crypto_unregister_ahash(&driver_algs[i].alg.hash);
> + dev_dbg(dev, " unregistered hash %s\n",
> + driver_algs[i].alg.hash.halg.
> + base.cra_driver_name);
> + driver_algs[i].registered = false;
> + break;
> + case CRYPTO_ALG_TYPE_AEAD:
> + crypto_unregister_aead(&driver_algs[i].alg.aead);
> + dev_dbg(dev, " unregistered aead %s\n",
> + driver_algs[i].alg.aead.base.cra_driver_name);
> + driver_algs[i].registered = false;
> + break;
> + }
> + }
> + spu_free_debugfs();
> + spu_mb_release(pdev);
> + return 0;
> +}
> +
> +/* ===== Kernel Module API ===== */
> +
> +static struct platform_driver bcm_spu_pdriver = {
> + .driver = {
> + .name = "brcm-spu-crypto",
> + .of_match_table = of_match_ptr(bcm_spu_dt_ids),
> + },
> + .probe = bcm_spu_probe,
> + .remove = bcm_spu_remove,
> +};
> +module_platform_driver(bcm_spu_pdriver);
> +
> +MODULE_AUTHOR("Rob Rice <rob.rice@broadcom.com>");
> +MODULE_DESCRIPTION("Broadcom symmetric crypto offload driver");
> +MODULE_LICENSE("GPL v2");
> diff --git a/drivers/crypto/bcm/cipher.h b/drivers/crypto/bcm/cipher.h
> new file mode 100644
> index 0000000..2d856bd
> --- /dev/null
> +++ b/drivers/crypto/bcm/cipher.h
> @@ -0,0 +1,472 @@
> +/*
> + * Copyright 2016 Broadcom
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License, version 2, as
> + * published by the Free Software Foundation (the "GPL").
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * General Public License version 2 (GPLv2) for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * version 2 (GPLv2) along with this source code.
> + */
> +
> +#ifndef _CIPHER_H
> +#define _CIPHER_H
> +
> +#include <linux/atomic.h>
> +#include <linux/mailbox/brcm-message.h>
> +#include <linux/mailbox_client.h>
> +#include <crypto/aes.h>
> +#include <crypto/internal/hash.h>
> +#include <crypto/aead.h>
> +#include <crypto/sha.h>
> +#include <crypto/sha3.h>
> +
> +#include "spu.h"
> +#include "spum.h"
> +#include "spu2.h"
> +
> +#define ARC4_MIN_KEY_SIZE 1
> +#define ARC4_MAX_KEY_SIZE 256
> +#define ARC4_BLOCK_SIZE 1
> +#define ARC4_STATE_SIZE 4
> +
> +#define CCM_AES_IV_SIZE 16
> +#define GCM_AES_IV_SIZE 12
> +#define GCM_ESP_IV_SIZE 8
> +#define CCM_ESP_IV_SIZE 8
> +#define RFC4543_ICV_SIZE 16
> +
> +#define MAX_KEY_SIZE ARC4_MAX_KEY_SIZE
> +#define MAX_IV_SIZE AES_BLOCK_SIZE
> +#define MAX_DIGEST_SIZE SHA3_512_DIGEST_SIZE
> +#define MAX_ASSOC_SIZE 512
> +
> +/* size of salt value for AES-GCM-ESP and AES-CCM-ESP */
> +#define GCM_ESP_SALT_SIZE 4
> +#define CCM_ESP_SALT_SIZE 3
> +#define MAX_SALT_SIZE GCM_ESP_SALT_SIZE
> +#define GCM_ESP_SALT_OFFSET 0
> +#define CCM_ESP_SALT_OFFSET 1
> +
> +#define GCM_ESP_DIGESTSIZE 16
> +
> +#define MAX_HASH_BLOCK_SIZE SHA512_BLOCK_SIZE
> +
> +/*
> + * Maximum number of bytes from a non-final hash request that can be deferred
> + * until more data is available. With new crypto API framework, this
> + * can be no more than one block of data.
> + */
> +#define HASH_CARRY_MAX MAX_HASH_BLOCK_SIZE
> +
> +/* Force at least 4-byte alignment of all SPU message fields */
> +#define SPU_MSG_ALIGN 4
> +
> +/* Number of times to resend mailbox message if mb queue is full */
> +#define SPU_MB_RETRY_MAX 1000
> +
> +/* op_counts[] indexes */
> +enum op_type {
> + SPU_OP_CIPHER,
> + SPU_OP_HASH,
> + SPU_OP_HMAC,
> + SPU_OP_AEAD,
> + SPU_OP_NUM
> +};
> +
> +enum spu_spu_type {
> + SPU_TYPE_SPUM,
> + SPU_TYPE_SPU2,
> +};
> +
> +/*
> + * SPUM_NS2 and SPUM_NSP are the SPU-M block on Northstar 2 and Northstar Plus,
> + * respectively.
> + */
> +enum spu_spu_subtype {
> + SPU_SUBTYPE_SPUM_NS2,
> + SPU_SUBTYPE_SPUM_NSP,
> + SPU_SUBTYPE_SPU2_V1,
> + SPU_SUBTYPE_SPU2_V2
> +};
> +
> +struct spu_type_subtype {
> + enum spu_spu_type type;
> + enum spu_spu_subtype subtype;
> +};
> +
> +struct cipher_op {
> + enum spu_cipher_alg alg;
> + enum spu_cipher_mode mode;
> +};
> +
> +struct auth_op {
> + enum hash_alg alg;
> + enum hash_mode mode;
> +};
> +
> +struct iproc_alg_s {
> + u32 type;
> + union {
> + struct crypto_alg crypto;
> + struct ahash_alg hash;
> + struct aead_alg aead;
> + } alg;
> + struct cipher_op cipher_info;
> + struct auth_op auth_info;
> + bool auth_first;
> + bool registered;
> +};
> +
> +/*
> + * Buffers for a SPU request/reply message pair. All part of one structure to
> + * allow a single alloc per request.
> + */
> +struct spu_msg_buf {
> + /* Request message fragments */
> +
> + /*
> + * SPU request message header. For SPU-M, holds MH, EMH, SCTX, BDESC,
> + * and BD header. For SPU2, holds FMD, OMD.
> + */
> + u8 bcm_spu_req_hdr[ALIGN(SPU2_HEADER_ALLOC_LEN, SPU_MSG_ALIGN)];
> +
> + /* IV or counter. Size to include salt. Also used for XTS tweek. */
> + u8 iv_ctr[ALIGN(2 * AES_BLOCK_SIZE, SPU_MSG_ALIGN)];
> +
> + /* Hash digest. request and response. */
> + u8 digest[ALIGN(MAX_DIGEST_SIZE, SPU_MSG_ALIGN)];
> +
> + /* SPU request message padding */
> + u8 spu_req_pad[ALIGN(SPU_PAD_LEN_MAX, SPU_MSG_ALIGN)];
> +
> + /* SPU-M request message STATUS field */
> + u8 tx_stat[ALIGN(SPU_TX_STATUS_LEN, SPU_MSG_ALIGN)];
> +
> + /* Response message fragments */
> +
> + /* SPU response message header */
> + u8 spu_resp_hdr[ALIGN(SPU2_HEADER_ALLOC_LEN, SPU_MSG_ALIGN)];
> +
> + /* SPU response message STATUS field padding */
> + u8 rx_stat_pad[ALIGN(SPU_STAT_PAD_MAX, SPU_MSG_ALIGN)];
> +
> + /* SPU response message STATUS field */
> + u8 rx_stat[ALIGN(SPU_RX_STATUS_LEN, SPU_MSG_ALIGN)];
> +
> + union {
> + /* Buffers only used for ablkcipher */
> + struct {
> + /*
> + * Field used for either SUPDT when RC4 is used
> + * -OR- tweak value when XTS/AES is used
> + */
> + u8 supdt_tweak[ALIGN(SPU_SUPDT_LEN, SPU_MSG_ALIGN)];
> + } c;
> +
> + /* Buffers only used for aead */
> + struct {
> + /* SPU response pad for GCM data */
> + u8 gcmpad[ALIGN(AES_BLOCK_SIZE, SPU_MSG_ALIGN)];
> +
> + /* SPU request msg padding for GCM AAD */
> + u8 req_aad_pad[ALIGN(SPU_PAD_LEN_MAX, SPU_MSG_ALIGN)];
> +
> + /* SPU response data to be discarded */
> + u8 resp_aad[ALIGN(MAX_ASSOC_SIZE + MAX_IV_SIZE,
> + SPU_MSG_ALIGN)];
> + } a;
> + };
> +};
> +
> +struct iproc_ctx_s {
> + u8 enckey[MAX_KEY_SIZE + ARC4_STATE_SIZE];
> + unsigned int enckeylen;
> +
> + u8 authkey[MAX_KEY_SIZE + ARC4_STATE_SIZE];
> + unsigned int authkeylen;
> +
> + u8 salt[MAX_SALT_SIZE];
> + unsigned int salt_len;
> + unsigned int salt_offset;
> + u8 iv[MAX_IV_SIZE];
> +
> + unsigned int digestsize;
> +
> + struct iproc_alg_s *alg;
> + bool is_esp;
> +
> + struct cipher_op cipher;
> + enum spu_cipher_type cipher_type;
> +
> + struct auth_op auth;
> + bool auth_first;
> +
> + /*
> + * The maximum length in bytes of the payload in a SPU message for this
> + * context. For SPU-M, the payload is the combination of AAD and data.
> + * For SPU2, the payload is just data. A value of SPU_MAX_PAYLOAD_INF
> + * indicates that there is no limit to the length of the SPU message
> + * payload.
> + */
> + unsigned int max_payload;
> +
> + struct crypto_aead *fallback_cipher;
> +
> + /* auth_type is determined during processing of request */
> +
> + u8 ipad[MAX_HASH_BLOCK_SIZE];
> + u8 opad[MAX_HASH_BLOCK_SIZE];
> +
> + /*
> + * Buffer to hold SPU message header template. Template is created at
> + * setkey time for ablkcipher requests, since most of the fields in the
> + * header are known at that time. At request time, just fill in a few
> + * missing pieces related to length of data in the request and IVs, etc.
> + */
> + u8 bcm_spu_req_hdr[ALIGN(SPU2_HEADER_ALLOC_LEN, SPU_MSG_ALIGN)];
> +
> + /* Length of SPU request header */
> + u16 spu_req_hdr_len;
> +
> + /* Expected length of SPU response header */
> + u16 spu_resp_hdr_len;
> +
> + /*
> + * shash descriptor - needed to perform incremental hashing in
> + * in software, when hw doesn't support it.
> + */
> + struct shash_desc *shash;
> +
> + bool is_rfc4543; /* RFC 4543 style of GMAC */
> +};
> +
> +struct iproc_reqctx_s {
> + /* general context */
> + struct crypto_async_request *parent;
> +
> + /* only valid after enqueue() */
> + struct iproc_ctx_s *ctx;
> +
> + u8 chan_idx; /* Mailbox channel to be used to submit this request */
> +
> + /* total todo, rx'd, and sent for this request */
> + unsigned int total_todo;
> + unsigned int total_received; /* only valid for ablkcipher */
> + unsigned int total_sent;
> +
> + /*
> + * num bytes sent to hw from the src sg in this request. This can differ
> + * from total_sent for incremental hashing. total_sent includes previous
> + * init() and update() data. src_sent does not.
> + */
> + unsigned int src_sent;
> + unsigned int hmac_offset;
> +
> + /*
> + * For AEAD requests, start of associated data. This will typically
> + * point to the beginning of the src scatterlist from the request,
> + * since assoc data is at the beginning of the src scatterlist rather
> + * than in its own sg.
> + */
> + struct scatterlist *assoc;
> +
> + /*
> + * scatterlist entry and offset to start of data for next chunk. Crypto
> + * API src scatterlist for AEAD starts with AAD, if present. For first
> + * chunk, src_sg is sg entry at beginning of input data (after AAD).
> + * src_skip begins at the offset in that sg entry where data begins.
> + */
> + struct scatterlist *src_sg;
> + int src_nents; /* Number of src entries with data */
> + u32 src_skip; /* bytes of current sg entry already used */
> +
> + /*
> + * Same for destination. For AEAD, if there is AAD, output data must
> + * be written at offset following AAD.
> + */
> + struct scatterlist *dst_sg;
> + int dst_nents; /* Number of dst entries with data */
> + u32 dst_skip; /* bytes of current sg entry already written */
> +
> + /* Mailbox message used to send this request to PDC driver */
> + struct brcm_message mb_mssg;
> +
> + bool bd_suppress; /* suppress BD field in SPU response? */
> +
> + /* cipher context */
> + bool is_encrypt;
> +
> + /*
> + * CBC mode: IV. CTR mode: counter. Else empty. Used as a DMA
> + * buffer for AEAD requests. So allocate as DMAable memory. If IV
> + * concatenated with salt, includes the salt.
> + */
> + u8 *iv_ctr;
> + /* Length of IV or counter, in bytes */
> + unsigned int iv_ctr_len;
> +
> + /*
> + * Hash requests can be of any size, whether initial, update, or final.
> + * A non-final request must be submitted to the SPU as an integral
> + * number of blocks. This may leave data at the end of the request
> + * that is not a full block. Since the request is non-final, it cannot
> + * be padded. So, we write the remainder to this hash_carry buffer and
> + * hold it until the next request arrives. The carry data is then
> + * submitted at the beginning of the data in the next SPU msg.
> + * hash_carry_len is the number of bytes currently in hash_carry. These
> + * fields are only used for ahash requests.
> + */
> + u8 hash_carry[HASH_CARRY_MAX];
> + unsigned int hash_carry_len;
> + unsigned int is_final; /* is this the final for the hash op? */
> +
> + /*
> + * Digest from incremental hash is saved here to include in next hash
> + * operation. Cannot be stored in req->result for truncated hashes,
> + * since result may be sized for final digest. Cannot be saved in
> + * msg_buf because that gets deleted between incremental hash ops
> + * and is not saved as part of export().
> + */
> + u8 incr_hash[MAX_DIGEST_SIZE];
> +
> + /* hmac context */
> + bool is_sw_hmac;
> +
> + /* aead context */
> + struct crypto_tfm *old_tfm;
> + crypto_completion_t old_complete;
> + void *old_data;
> +
> + gfp_t gfp;
> +
> + /* Buffers used to build SPU request and response messages */
> + /* MUST BE LAST */
> + struct spu_msg_buf msg_buf;
> +};
> +
> +/*
> + * Structure encapsulates a set of function pointers specific to the type of
> + * SPU hardware running. These functions handling creation and parsing of
> + * SPU request messages and SPU response messages. Includes hardware-specific
> + * values read from device tree.
> + */
> +struct spu_hw {
> + void (*spu_dump_msg_hdr)(u8 *buf, unsigned int buf_len);
> + u32 (*spu_ctx_max_payload)(enum spu_cipher_alg cipher_alg,
> + enum spu_cipher_mode cipher_mode,
> + unsigned int blocksize);
> + u32 (*spu_payload_length)(u8 *spu_hdr);
> + u16 (*spu_response_hdr_len)(u16 auth_key_len, u16 enc_key_len,
> + bool is_hash);
> + u16 (*spu_hash_pad_len)(enum hash_alg hash_alg,
> + enum hash_mode hash_mode, u32 chunksize,
> + u16 hash_block_size);
> + u32 (*spu_gcm_ccm_pad_len)(enum spu_cipher_mode cipher_mode,
> + unsigned int data_size);
> + u32 (*spu_assoc_resp_len)(enum spu_cipher_mode cipher_mode,
> + unsigned int assoc_len,
> + unsigned int iv_len, bool is_encrypt);
> + u8 (*spu_aead_ivlen)(enum spu_cipher_mode cipher_mode,
> + u16 iv_len);
> + enum hash_type (*spu_hash_type)(u32 src_sent);
> + u32 (*spu_digest_size)(u32 digest_size, enum hash_alg alg,
> + enum hash_type);
> + u32 (*spu_create_request)(u8 *spu_hdr,
> + struct spu_request_opts *req_opts,
> + struct spu_cipher_parms *cipher_parms,
> + struct spu_hash_parms *hash_parms,
> + struct spu_aead_parms *aead_parms,
> + unsigned int data_size);
> + u16 (*spu_cipher_req_init)(u8 *spu_hdr,
> + struct spu_cipher_parms *cipher_parms);
> + void (*spu_cipher_req_finish)(u8 *spu_hdr,
> + u16 spu_req_hdr_len,
> + unsigned int is_inbound,
> + struct spu_cipher_parms *cipher_parms,
> + bool update_key,
> + unsigned int data_size);
> + void (*spu_request_pad)(u8 *pad_start, u32 gcm_padding,
> + u32 hash_pad_len, enum hash_alg auth_alg,
> + enum hash_mode auth_mode,
> + unsigned int total_sent, u32 status_padding);
> + u8 (*spu_xts_tweak_in_payload)(void);
> + u8 (*spu_tx_status_len)(void);
> + u8 (*spu_rx_status_len)(void);
> + int (*spu_status_process)(u8 *statp);
> + void (*spu_ccm_update_iv)(unsigned int digestsize,
> + struct spu_cipher_parms *cipher_parms,
> + unsigned int assoclen, unsigned int chunksize,
> + bool is_encrypt, bool is_esp);
> + u32 (*spu_wordalign_padlen)(u32 data_size);
> +
> + /* The base virtual address of the SPU hw registers */
> + void __iomem **reg_vbase;
> +
> + /* Version of the SPU hardware */
> + enum spu_spu_type spu_type;
> +
> + /* Sub-version of the SPU hardware */
> + enum spu_spu_subtype spu_subtype;
> +
> + /* The number of SPUs on this platform */
> + u32 num_spu;
> +
> + /* The number of SPU channels on this platform */
> + u32 num_chan;
> +};
> +
> +struct device_private {
> + struct platform_device *pdev;
> +
> + struct spu_hw spu;
> +
> + atomic_t session_count; /* number of streams active */
> + atomic_t stream_count; /* monotonic counter for streamID's */
> +
> + /* Length of BCM header. Set to 0 when hw does not expect BCM HEADER. */
> + u8 bcm_hdr_len;
> +
> + /* The index of the channel to use for the next crypto request */
> + atomic_t next_chan;
> +
> + struct dentry *debugfs_dir;
> + struct dentry *debugfs_stats;
> +
> + /* Number of request bytes processed and result bytes returned */
> + atomic64_t bytes_in;
> + atomic64_t bytes_out;
> +
> + /* Number of operations of each type */
> + atomic_t op_counts[SPU_OP_NUM];
> +
> + atomic_t cipher_cnt[CIPHER_ALG_LAST][CIPHER_MODE_LAST];
> + atomic_t hash_cnt[HASH_ALG_LAST];
> + atomic_t hmac_cnt[HASH_ALG_LAST];
> + atomic_t aead_cnt[AEAD_TYPE_LAST];
> +
> + /* Number of calls to setkey() for each operation type */
> + atomic_t setkey_cnt[SPU_OP_NUM];
> +
> + /* Number of times request was resubmitted because mb was full */
> + atomic_t mb_no_spc;
> +
> + /* Number of mailbox send failures */
> + atomic_t mb_send_fail;
> +
> + /* Number of ICV check failures for AEAD messages */
> + atomic_t bad_icv;
> +
> + struct mbox_client mcl;
> + /* Array of mailbox channel pointers, one for each channel */
> + struct mbox_chan **mbox;
> +};
> +
> +extern struct device_private iproc_priv;
> +
> +#endif
> diff --git a/drivers/crypto/bcm/spu.c b/drivers/crypto/bcm/spu.c
> new file mode 100644
> index 0000000..0331267
> --- /dev/null
> +++ b/drivers/crypto/bcm/spu.c
> @@ -0,0 +1,1252 @@
> +/*
> + * Copyright 2016 Broadcom
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License, version 2, as
> + * published by the Free Software Foundation (the "GPL").
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * General Public License version 2 (GPLv2) for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * version 2 (GPLv2) along with this source code.
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/string.h>
> +
> +#include "util.h"
> +#include "spu.h"
> +#include "spum.h"
> +#include "cipher.h"
> +
> +/* This array is based on the hash algo type supported in spu.h */
> +char *tag_to_hash_idx[] = { "none", "md5", "sha1", "sha224", "sha256" };
> +
> +char *hash_alg_name[] = { "None", "md5", "sha1", "sha224", "sha256", "aes",
> + "sha384", "sha512", "sha3_224", "sha3_256", "sha3_384", "sha3_512" };
> +
> +char *aead_alg_name[] = { "ccm(aes)", "gcm(aes)", "authenc" };
> +
> +/* Assumes SPU-M messages are in big endian */
> +void spum_dump_msg_hdr(u8 *buf, unsigned int buf_len)
> +{
> + u8 *ptr = buf;
> + struct SPUHEADER *spuh = (struct SPUHEADER *)buf;
> + unsigned int hash_key_len = 0;
> + unsigned int hash_state_len = 0;
> + unsigned int cipher_key_len = 0;
> + unsigned int iv_len;
> + u32 pflags;
> + u32 cflags;
> + u32 ecf;
> + u32 cipher_alg;
> + u32 cipher_mode;
> + u32 cipher_type;
> + u32 hash_alg;
> + u32 hash_mode;
> + u32 hash_type;
> + u32 sctx_size; /* SCTX length in words */
> + u32 sctx_pl_len; /* SCTX payload length in bytes */
> +
> + packet_log("\n");
> + packet_log("SPU Message header %p len: %u\n", buf, buf_len);
> +
> + /* ========== Decode MH ========== */
> + packet_log(" MH 0x%08x\n", be32_to_cpu(*((u32 *)ptr)));
> + if (spuh->mh.flags & MH_SCTX_PRES)
> + packet_log(" SCTX present\n");
> + if (spuh->mh.flags & MH_BDESC_PRES)
> + packet_log(" BDESC present\n");
> + if (spuh->mh.flags & MH_MFM_PRES)
> + packet_log(" MFM present\n");
> + if (spuh->mh.flags & MH_BD_PRES)
> + packet_log(" BD present\n");
> + if (spuh->mh.flags & MH_HASH_PRES)
> + packet_log(" HASH present\n");
> + if (spuh->mh.flags & MH_SUPDT_PRES)
> + packet_log(" SUPDT present\n");
> + packet_log(" Opcode 0x%02x\n", spuh->mh.op_code);
> +
> + ptr += sizeof(spuh->mh) + sizeof(spuh->emh); /* skip emh. unused */
> +
> + /* ========== Decode SCTX ========== */
> + if (spuh->mh.flags & MH_SCTX_PRES) {
> + pflags = be32_to_cpu(spuh->sa.proto_flags);
> + packet_log(" SCTX[0] 0x%08x\n", pflags);
> + sctx_size = pflags & SCTX_SIZE;
> + packet_log(" Size %u words\n", sctx_size);
> +
> + cflags = be32_to_cpu(spuh->sa.cipher_flags);
> + packet_log(" SCTX[1] 0x%08x\n", cflags);
> + packet_log(" Inbound:%lu (1:decrypt/vrfy 0:encrypt/auth)\n",
> + (cflags & CIPHER_INBOUND) >> CIPHER_INBOUND_SHIFT);
> + packet_log(" Order:%lu (1:AuthFirst 0:EncFirst)\n",
> + (cflags & CIPHER_ORDER) >> CIPHER_ORDER_SHIFT);
> + packet_log(" ICV_IS_512:%lx\n",
> + (cflags & ICV_IS_512) >> ICV_IS_512_SHIFT);
> + cipher_alg = (cflags & CIPHER_ALG) >> CIPHER_ALG_SHIFT;
> + cipher_mode = (cflags & CIPHER_MODE) >> CIPHER_MODE_SHIFT;
> + cipher_type = (cflags & CIPHER_TYPE) >> CIPHER_TYPE_SHIFT;
> + packet_log(" Crypto Alg:%u Mode:%u Type:%u\n",
> + cipher_alg, cipher_mode, cipher_type);
> + hash_alg = (cflags & HASH_ALG) >> HASH_ALG_SHIFT;
> + hash_mode = (cflags & HASH_MODE) >> HASH_MODE_SHIFT;
> + hash_type = (cflags & HASH_TYPE) >> HASH_TYPE_SHIFT;
> + packet_log(" Hash Alg:%x Mode:%x Type:%x\n",
> + hash_alg, hash_mode, hash_type);
> + packet_log(" UPDT_Offset:%u\n", cflags & UPDT_OFST);
> +
> + ecf = be32_to_cpu(spuh->sa.ecf);
> + packet_log(" SCTX[2] 0x%08x\n", ecf);
> + packet_log(" WriteICV:%lu CheckICV:%lu ICV_SIZE:%u ",
> + (ecf & INSERT_ICV) >> INSERT_ICV_SHIFT,
> + (ecf & CHECK_ICV) >> CHECK_ICV_SHIFT,
> + (ecf & ICV_SIZE) >> ICV_SIZE_SHIFT);
> + packet_log("BD_SUPPRESS:%lu\n",
> + (ecf & BD_SUPPRESS) >> BD_SUPPRESS_SHIFT);
> + packet_log(" SCTX_IV:%lu ExplicitIV:%lu GenIV:%lu ",
> + (ecf & SCTX_IV) >> SCTX_IV_SHIFT,
> + (ecf & EXPLICIT_IV) >> EXPLICIT_IV_SHIFT,
> + (ecf & GEN_IV) >> GEN_IV_SHIFT);
> + packet_log("IV_OV_OFST:%lu EXP_IV_SIZE:%u\n",
> + (ecf & IV_OFFSET) >> IV_OFFSET_SHIFT,
> + ecf & EXP_IV_SIZE);
> +
> + ptr += sizeof(struct SCTX);
> +
> + if (hash_alg && hash_mode) {
> + char *name = "NONE";
> +
> + switch (hash_alg) {
> + case HASH_ALG_MD5:
> + hash_key_len = 16;
> + name = "MD5";
> + break;
> + case HASH_ALG_SHA1:
> + hash_key_len = 20;
> + name = "SHA1";
> + break;
> + case HASH_ALG_SHA224:
> + hash_key_len = 28;
> + name = "SHA224";
> + break;
> + case HASH_ALG_SHA256:
> + hash_key_len = 32;
> + name = "SHA256";
> + break;
> + case HASH_ALG_SHA384:
> + hash_key_len = 48;
> + name = "SHA384";
> + break;
> + case HASH_ALG_SHA512:
> + hash_key_len = 64;
> + name = "SHA512";
> + break;
> + case HASH_ALG_AES:
> + hash_key_len = 0;
> + name = "AES";
> + break;
> + case HASH_ALG_NONE:
> + break;
> + }
> +
> + packet_log(" Auth Key Type:%s Length:%u Bytes\n",
> + name, hash_key_len);
> + packet_dump(" KEY: ", ptr, hash_key_len);
> + ptr += hash_key_len;
> + } else if ((hash_alg == HASH_ALG_AES) &&
> + (hash_mode == HASH_MODE_XCBC)) {
> + char *name = "NONE";
> +
> + switch (cipher_type) {
> + case CIPHER_TYPE_AES128:
> + hash_key_len = 16;
> + name = "AES128-XCBC";
> + break;
> + case CIPHER_TYPE_AES192:
> + hash_key_len = 24;
> + name = "AES192-XCBC";
> + break;
> + case CIPHER_TYPE_AES256:
> + hash_key_len = 32;
> + name = "AES256-XCBC";
> + break;
> + }
> + packet_log(" Auth Key Type:%s Length:%u Bytes\n",
> + name, hash_key_len);
> + packet_dump(" KEY: ", ptr, hash_key_len);
> + ptr += hash_key_len;
> + }
> +
> + if (hash_alg && (hash_mode == HASH_MODE_NONE) &&
> + (hash_type == HASH_TYPE_UPDT)) {
> + char *name = "NONE";
> +
> + switch (hash_alg) {
> + case HASH_ALG_MD5:
> + hash_state_len = 16;
> + name = "MD5";
> + break;
> + case HASH_ALG_SHA1:
> + hash_state_len = 20;
> + name = "SHA1";
> + break;
> + case HASH_ALG_SHA224:
> + hash_state_len = 32;
> + name = "SHA224";
> + break;
> + case HASH_ALG_SHA256:
> + hash_state_len = 32;
> + name = "SHA256";
> + break;
> + case HASH_ALG_SHA384:
> + hash_state_len = 48;
> + name = "SHA384";
> + break;
> + case HASH_ALG_SHA512:
> + hash_state_len = 64;
> + name = "SHA512";
> + break;
> + case HASH_ALG_AES:
> + hash_state_len = 0;
> + name = "AES";
> + break;
> + case HASH_ALG_NONE:
> + break;
> + }
> +
> + packet_log(" Auth State Type:%s Length:%u Bytes\n",
> + name, hash_state_len);
> + packet_dump(" State: ", ptr, hash_state_len);
> + ptr += hash_state_len;
> + }
> +
> + if (cipher_alg) {
> + char *name = "NONE";
> +
> + switch (cipher_alg) {
> + case CIPHER_ALG_DES:
> + cipher_key_len = 8;
> + name = "DES";
> + break;
> + case CIPHER_ALG_3DES:
> + cipher_key_len = 24;
> + name = "3DES";
> + break;
> + case CIPHER_ALG_RC4:
> + cipher_key_len = 260;
> + name = "ARC4";
> + break;
> + case CIPHER_ALG_AES:
> + switch (cipher_type) {
> + case CIPHER_TYPE_AES128:
> + cipher_key_len = 16;
> + name = "AES128";
> + break;
> + case CIPHER_TYPE_AES192:
> + cipher_key_len = 24;
> + name = "AES192";
> + break;
> + case CIPHER_TYPE_AES256:
> + cipher_key_len = 32;
> + name = "AES256";
> + break;
> + }
> + break;
> + case CIPHER_ALG_NONE:
> + break;
> + }
> +
> + packet_log(" Cipher Key Type:%s Length:%u Bytes\n",
> + name, cipher_key_len);
> +
> + /* XTS has two keys */
> + if (cipher_mode == CIPHER_MODE_XTS) {
> + packet_dump(" KEY2: ", ptr, cipher_key_len);
> + ptr += cipher_key_len;
> + packet_dump(" KEY1: ", ptr, cipher_key_len);
> + ptr += cipher_key_len;
> +
> + cipher_key_len *= 2;
> + } else {
> + packet_dump(" KEY: ", ptr, cipher_key_len);
> + ptr += cipher_key_len;
> + }
> +
> + if (ecf & SCTX_IV) {
> + sctx_pl_len = sctx_size * sizeof(u32) -
> + sizeof(struct SCTX);
> + iv_len = sctx_pl_len -
> + (hash_key_len + hash_state_len +
> + cipher_key_len);
> + packet_log(" IV Length:%u Bytes\n", iv_len);
> + packet_dump(" IV: ", ptr, iv_len);
> + ptr += iv_len;
> + }
> + }
> + }
> +
> + /* ========== Decode BDESC ========== */
> + if (spuh->mh.flags & MH_BDESC_PRES) {
> +#ifdef DEBUG
> + struct BDESC_HEADER *bdesc = (struct BDESC_HEADER *)ptr;
> +#endif
> + packet_log(" BDESC[0] 0x%08x\n", be32_to_cpu(*((u32 *)ptr)));
> + packet_log(" OffsetMAC:%u LengthMAC:%u\n",
> + be16_to_cpu(bdesc->offset_mac),
> + be16_to_cpu(bdesc->length_mac));
> + ptr += sizeof(u32);
> +
> + packet_log(" BDESC[1] 0x%08x\n", be32_to_cpu(*((u32 *)ptr)));
> + packet_log(" OffsetCrypto:%u LengthCrypto:%u\n",
> + be16_to_cpu(bdesc->offset_crypto),
> + be16_to_cpu(bdesc->length_crypto));
> + ptr += sizeof(u32);
> +
> + packet_log(" BDESC[2] 0x%08x\n", be32_to_cpu(*((u32 *)ptr)));
> + packet_log(" OffsetICV:%u OffsetIV:%u\n",
> + be16_to_cpu(bdesc->offset_icv),
> + be16_to_cpu(bdesc->offset_iv));
> + ptr += sizeof(u32);
> + }
> +
> + /* ========== Decode BD ========== */
> + if (spuh->mh.flags & MH_BD_PRES) {
> +#ifdef DEBUG
> + struct BD_HEADER *bd = (struct BD_HEADER *)ptr;
> +#endif
> + packet_log(" BD[0] 0x%08x\n", be32_to_cpu(*((u32 *)ptr)));
> + packet_log(" Size:%ubytes PrevLength:%u\n",
> + be16_to_cpu(bd->size), be16_to_cpu(bd->prev_length));
> + ptr += 4;
> + }
> +
> + /* Double check sanity */
> + if (buf + buf_len != ptr) {
> + packet_log(" Packet parsed incorrectly. ");
> + packet_log("buf:%p buf_len:%u buf+buf_len:%p ptr:%p\n",
> + buf, buf_len, buf + buf_len, ptr);
> + }
> +
> + packet_log("\n");
> +}
> +
> +/**
> + * spum_ns2_ctx_max_payload() - Determine the max length of the payload for a
> + * SPU message for a given cipher and hash alg context.
> + * @cipher_alg: The cipher algorithm
> + * @cipher_mode: The cipher mode
> + * @blocksize: The size of a block of data for this algo
> + *
> + * The max payload must be a multiple of the blocksize so that if a request is
> + * too large to fit in a single SPU message, the request can be broken into
> + * max_payload sized chunks. Each chunk must be a multiple of blocksize.
> + *
> + * Return: Max payload length in bytes
> + */
> +u32 spum_ns2_ctx_max_payload(enum spu_cipher_alg cipher_alg,
> + enum spu_cipher_mode cipher_mode,
> + unsigned int blocksize)
> +{
> + u32 max_payload = SPUM_NS2_MAX_PAYLOAD;
> + u32 excess;
> +
> + /* In XTS on SPU-M, we'll need to insert tweak before input data */
> + if (cipher_mode == CIPHER_MODE_XTS)
> + max_payload -= SPU_XTS_TWEAK_SIZE;
> +
> + excess = max_payload % blocksize;
> +
> + return max_payload - excess;
> +}
> +
> +/**
> + * spum_nsp_ctx_max_payload() - Determine the max length of the payload for a
> + * SPU message for a given cipher and hash alg context.
> + * @cipher_alg: The cipher algorithm
> + * @cipher_mode: The cipher mode
> + * @blocksize: The size of a block of data for this algo
> + *
> + * The max payload must be a multiple of the blocksize so that if a request is
> + * too large to fit in a single SPU message, the request can be broken into
> + * max_payload sized chunks. Each chunk must be a multiple of blocksize.
> + *
> + * Return: Max payload length in bytes
> + */
> +u32 spum_nsp_ctx_max_payload(enum spu_cipher_alg cipher_alg,
> + enum spu_cipher_mode cipher_mode,
> + unsigned int blocksize)
> +{
> + u32 max_payload = SPUM_NSP_MAX_PAYLOAD;
> + u32 excess;
> +
> + /* In XTS on SPU-M, we'll need to insert tweak before input data */
> + if (cipher_mode == CIPHER_MODE_XTS)
> + max_payload -= SPU_XTS_TWEAK_SIZE;
> +
> + excess = max_payload % blocksize;
> +
> + return max_payload - excess;
> +}
> +
> +/** spum_payload_length() - Given a SPU-M message header, extract the payload
> + * length.
> + * @spu_hdr: Start of SPU header
> + *
> + * Assumes just MH, EMH, BD (no SCTX, BDESC. Works for response frames.
> + *
> + * Return: payload length in bytes
> + */
> +u32 spum_payload_length(u8 *spu_hdr)
> +{
> + struct BD_HEADER *bd;
> + u32 pl_len;
> +
> + /* Find BD header. skip MH, EMH */
> + bd = (struct BD_HEADER *)(spu_hdr + 8);
> + pl_len = be16_to_cpu(bd->size);
> +
> + return pl_len;
> +}
> +
> +/**
> + * spum_response_hdr_len() - Given the length of the hash key and encryption
> + * key, determine the expected length of a SPU response header.
> + * @auth_key_len: authentication key length (bytes)
> + * @enc_key_len: encryption key length (bytes)
> + * @is_hash: true if response message is for a hash operation
> + *
> + * Return: length of SPU response header (bytes)
> + */
> +u16 spum_response_hdr_len(u16 auth_key_len, u16 enc_key_len, bool is_hash)
> +{
> + if (is_hash)
> + return SPU_HASH_RESP_HDR_LEN;
> + else
> + return SPU_RESP_HDR_LEN;
> +}
> +
> +/**
> + * spum_hash_pad_len() - Calculate the length of hash padding required to extend
> + * data to a full block size.
> + * @hash_alg: hash algorithm
> + * @hash_mode: hash mode
> + * @chunksize: length of data, in bytes
> + * @hash_block_size: size of a block of data for hash algorithm
> + *
> + * Reserve space for 1 byte (0x80) start of pad and the total length as u64
> + *
> + * Return: length of hash pad in bytes
> + */
> +u16 spum_hash_pad_len(enum hash_alg hash_alg, enum hash_mode hash_mode,
> + u32 chunksize, u16 hash_block_size)
> +{
> + unsigned int length_len;
> + unsigned int used_space_last_block;
> + int hash_pad_len;
> +
> + /* AES-XCBC hash requires just padding to next block boundary */
> + if ((hash_alg == HASH_ALG_AES) && (hash_mode == HASH_MODE_XCBC)) {
> + used_space_last_block = chunksize % hash_block_size;
> + hash_pad_len = hash_block_size - used_space_last_block;
> + if (hash_pad_len >= hash_block_size)
> + hash_pad_len -= hash_block_size;
> + return hash_pad_len;
> + }
> +
> + used_space_last_block = chunksize % hash_block_size + 1;
> + if ((hash_alg == HASH_ALG_SHA384) || (hash_alg == HASH_ALG_SHA512))
> + length_len = 2 * sizeof(u64);
> + else
> + length_len = sizeof(u64);
> +
> + used_space_last_block += length_len;
> + hash_pad_len = hash_block_size - used_space_last_block;
> + if (hash_pad_len < 0)
> + hash_pad_len += hash_block_size;
> +
> + hash_pad_len += 1 + length_len;
> + return hash_pad_len;
> +}
> +
> +/**
> + * spum_gcm_ccm_pad_len() - Determine the required length of GCM or CCM padding.
> + * @cipher_mode: Algo type
> + * @data_size: Length of plaintext (bytes)
> + *
> + * @Return: Length of padding, in bytes
> + */
> +u32 spum_gcm_ccm_pad_len(enum spu_cipher_mode cipher_mode,
> + unsigned int data_size)
> +{
> + u32 pad_len = 0;
> + u32 m1 = SPU_GCM_CCM_ALIGN - 1;
> +
> + if ((cipher_mode == CIPHER_MODE_GCM) ||
> + (cipher_mode == CIPHER_MODE_CCM))
> + pad_len = ((data_size + m1) & ~m1) - data_size;
> +
> + return pad_len;
> +}
> +
> +/**
> + * spum_assoc_resp_len() - Determine the size of the receive buffer required to
> + * catch associated data.
> + * @cipher_mode: cipher mode
> + * @assoc_len: length of associated data (bytes)
> + * @iv_len: length of IV (bytes)
> + * @is_encrypt: true if encrypting. false if decrypting.
> + *
> + * Return: length of associated data in response message (bytes)
> + */
> +u32 spum_assoc_resp_len(enum spu_cipher_mode cipher_mode,
> + unsigned int assoc_len, unsigned int iv_len,
> + bool is_encrypt)
> +{
> + u32 buflen = 0;
> + u32 pad;
> +
> + if (assoc_len)
> + buflen = assoc_len;
> +
> + if (cipher_mode == CIPHER_MODE_GCM) {
> + /* AAD needs to be padded in responses too */
> + pad = spum_gcm_ccm_pad_len(cipher_mode, buflen);
> + buflen += pad;
> + }
> + if (cipher_mode == CIPHER_MODE_CCM) {
> + /*
> + * AAD needs to be padded in responses too
> + * for CCM, len + 2 needs to be 128-bit aligned.
> + */
> + pad = spum_gcm_ccm_pad_len(cipher_mode, buflen + 2);
> + buflen += pad;
> + }
> +
> + return buflen;
> +}
> +
> +/**
> + * spu_aead_ivlen() - Calculate the length of the AEAD IV to be included
> + * in a SPU request after the AAD and before the payload.
> + * @cipher_mode: cipher mode
> + * @iv_ctr_len: initialization vector length in bytes
> + *
> + * In Linux ~4.2 and later, the assoc_data sg includes the IV. So no need
> + * to include the IV as a separate field in the SPU request msg.
> + *
> + * Return: Length of AEAD IV in bytes
> + */
> +u8 spum_aead_ivlen(enum spu_cipher_mode cipher_mode, u16 iv_len)
> +{
> + return 0;
> +}
> +
> +/**
> + * spum_hash_type() - Determine the type of hash operation.
> + * @src_sent: The number of bytes in the current request that have already
> + * been sent to the SPU to be hashed.
> + *
> + * We do not use HASH_TYPE_FULL for requests that fit in a single SPU message.
> + * Using FULL causes failures (such as when the string to be hashed is empty).
> + * For similar reasons, we never use HASH_TYPE_FIN. Instead, submit messages
> + * as INIT or UPDT and do the hash padding in sw.
> + */
> +enum hash_type spum_hash_type(u32 src_sent)
> +{
> + return src_sent ? HASH_TYPE_UPDT : HASH_TYPE_INIT;
> +}
> +
> +/**
> + * spum_digest_size() - Determine the size of a hash digest to expect the SPU to
> + * return.
> + * alg_digest_size: Number of bytes in the final digest for the given algo
> + * alg: The hash algorithm
> + * htype: Type of hash operation (init, update, full, etc)
> + *
> + * When doing incremental hashing for an algorithm with a truncated hash
> + * (e.g., SHA224), the SPU returns the full digest so that it can be fed back as
> + * a partial result for the next chunk.
> + */
> +u32 spum_digest_size(u32 alg_digest_size, enum hash_alg alg,
> + enum hash_type htype)
> +{
> + u32 digestsize = alg_digest_size;
> +
> + /* SPU returns complete digest when doing incremental hash and truncated
> + * hash algo.
> + */
> + if ((htype == HASH_TYPE_INIT) || (htype == HASH_TYPE_UPDT)) {
> + if (alg == HASH_ALG_SHA224)
> + digestsize = SHA256_DIGEST_SIZE;
> + else if (alg == HASH_ALG_SHA384)
> + digestsize = SHA512_DIGEST_SIZE;
> + }
> + return digestsize;
> +}
> +
> +/**
> + * spum_create_request() - Build a SPU request message header, up to and
> + * including the BD header. Construct the message starting at spu_hdr. Caller
> + * should allocate this buffer in DMA-able memory at least SPU_HEADER_ALLOC_LEN
> + * bytes long.
> + * @spu_hdr: Start of buffer where SPU request header is to be written
> + * @req_opts: SPU request message options
> + * @cipher_parms: Parameters related to cipher algorithm
> + * @hash_parms: Parameters related to hash algorithm
> + * @aead_parms: Parameters related to AEAD operation
> + * @data_size: Length of data to be encrypted or authenticated. If AEAD, does
> + * not include length of AAD.
> +
> + * Return: the length of the SPU header in bytes. 0 if an error occurs.
> + */
> +u32 spum_create_request(u8 *spu_hdr,
> + struct spu_request_opts *req_opts,
> + struct spu_cipher_parms *cipher_parms,
> + struct spu_hash_parms *hash_parms,
> + struct spu_aead_parms *aead_parms,
> + unsigned int data_size)
> +{
> + struct SPUHEADER *spuh;
> + struct BDESC_HEADER *bdesc;
> + struct BD_HEADER *bd;
> +
> + u8 *ptr;
> + u32 protocol_bits = 0;
> + u32 cipher_bits = 0;
> + u32 ecf_bits = 0;
> + u8 sctx_words = 0;
> + unsigned int buf_len = 0;
> +
> + /* size of the cipher payload */
> + unsigned int cipher_len = hash_parms->prebuf_len + data_size +
> + hash_parms->pad_len;
> +
> + /* offset of prebuf or data from end of BD header */
> + unsigned int cipher_offset = aead_parms->assoc_size +
> + aead_parms->iv_len + aead_parms->aad_pad_len;
> +
> + /* total size of the DB data (without STAT word padding) */
> + unsigned int real_db_size = spu_real_db_size(aead_parms->assoc_size,
> + aead_parms->iv_len,
> + hash_parms->prebuf_len,
> + data_size,
> + aead_parms->aad_pad_len,
> + aead_parms->data_pad_len,
> + hash_parms->pad_len);
> +
> + unsigned int auth_offset = 0;
> + unsigned int offset_iv = 0;
> +
> + /* size/offset of the auth payload */
> + unsigned int auth_len;
> +
> + auth_len = real_db_size;
> +
> + if (req_opts->is_aead && req_opts->is_inbound)
> + cipher_len -= hash_parms->digestsize;
> +
> + if (req_opts->is_aead && req_opts->is_inbound)
> + auth_len -= hash_parms->digestsize;
> +
> + if ((hash_parms->alg == HASH_ALG_AES) &&
> + (hash_parms->mode == HASH_MODE_XCBC)) {
> + auth_len -= hash_parms->pad_len;
> + cipher_len -= hash_parms->pad_len;
> + }
> +
> + flow_log("%s()\n", __func__);
> + flow_log(" in:%u authFirst:%u\n",
> + req_opts->is_inbound, req_opts->auth_first);
> + flow_log(" %s. cipher alg:%u mode:%u type %u\n",
> + spu_alg_name(cipher_parms->alg, cipher_parms->mode),
> + cipher_parms->alg, cipher_parms->mode, cipher_parms->type);
> + flow_log(" key: %d\n", cipher_parms->key_len);
> + flow_dump(" key: ", cipher_parms->key_buf, cipher_parms->key_len);
> + flow_log(" iv: %d\n", cipher_parms->iv_len);
> + flow_dump(" iv: ", cipher_parms->iv_buf, cipher_parms->iv_len);
> + flow_log(" auth alg:%u mode:%u type %u\n",
> + hash_parms->alg, hash_parms->mode, hash_parms->type);
> + flow_log(" digestsize: %u\n", hash_parms->digestsize);
> + flow_log(" authkey: %d\n", hash_parms->key_len);
> + flow_dump(" authkey: ", hash_parms->key_buf, hash_parms->key_len);
> + flow_log(" assoc_size:%u\n", aead_parms->assoc_size);
> + flow_log(" prebuf_len:%u\n", hash_parms->prebuf_len);
> + flow_log(" data_size:%u\n", data_size);
> + flow_log(" hash_pad_len:%u\n", hash_parms->pad_len);
> + flow_log(" real_db_size:%u\n", real_db_size);
> + flow_log(" auth_offset:%u auth_len:%u cipher_offset:%u cipher_len:%u\n",
> + auth_offset, auth_len, cipher_offset, cipher_len);
> + flow_log(" hmac_offset:%u\n", hash_parms->hmac_offset);
> + flow_log(" aead_iv: %u\n", aead_parms->iv_len);
> +
> + /* starting out: zero the header (plus some) */
> + ptr = spu_hdr;
> + memset(ptr, 0, sizeof(struct SPUHEADER));
> +
> + /* format master header word */
> + /* Do not set the next bit even though the datasheet says to */
> + spuh = (struct SPUHEADER *)ptr;
> + ptr += sizeof(struct SPUHEADER);
> + buf_len += sizeof(struct SPUHEADER);
> +
> + spuh->mh.op_code = SPU_CRYPTO_OPERATION_GENERIC;
> + spuh->mh.flags |= (MH_SCTX_PRES | MH_BDESC_PRES | MH_BD_PRES);
> +
> + /* Format sctx word 0 (protocol_bits) */
> + sctx_words = 3; /* size in words */
> +
> + /* Format sctx word 1 (cipher_bits) */
> + if (req_opts->is_inbound)
> + cipher_bits |= CIPHER_INBOUND;
> + if (req_opts->auth_first)
> + cipher_bits |= CIPHER_ORDER;
> +
> + /* Set the crypto parameters in the cipher.flags */
> + cipher_bits |= cipher_parms->alg << CIPHER_ALG_SHIFT;
> + cipher_bits |= cipher_parms->mode << CIPHER_MODE_SHIFT;
> + cipher_bits |= cipher_parms->type << CIPHER_TYPE_SHIFT;
> +
> + /* Set the auth parameters in the cipher.flags */
> + cipher_bits |= hash_parms->alg << HASH_ALG_SHIFT;
> + cipher_bits |= hash_parms->mode << HASH_MODE_SHIFT;
> + cipher_bits |= hash_parms->type << HASH_TYPE_SHIFT;
> +
> + /*
> + * Format sctx extensions if required, and update main fields if
> + * required)
> + */
> + if (hash_parms->alg) {
> + /* Write the authentication key material if present */
> + if (hash_parms->key_len) {
> + memcpy(ptr, hash_parms->key_buf, hash_parms->key_len);
> + ptr += hash_parms->key_len;
> + buf_len += hash_parms->key_len;
> + sctx_words += hash_parms->key_len / 4;
> + }
> +
> + if ((cipher_parms->mode == CIPHER_MODE_GCM) ||
> + (cipher_parms->mode == CIPHER_MODE_CCM))
> + /* unpadded length */
> + offset_iv = aead_parms->assoc_size;
> +
> + /* if GCM/CCM we need to write ICV into the payload */
> + if (!req_opts->is_inbound) {
> + if ((cipher_parms->mode == CIPHER_MODE_GCM) ||
> + (cipher_parms->mode == CIPHER_MODE_CCM))
> + ecf_bits |= 1 << INSERT_ICV_SHIFT;
> + } else {
> + ecf_bits |= CHECK_ICV;
> + }
> +
> + /* Inform the SPU of the ICV size (in words) */
> + if (hash_parms->digestsize == 64)
> + cipher_bits |= ICV_IS_512;
> + else
> + ecf_bits |=
> + (hash_parms->digestsize / 4) << ICV_SIZE_SHIFT;
> + }
> +
> + if (req_opts->bd_suppress)
> + ecf_bits |= BD_SUPPRESS;
> +
> + /* copy the encryption keys in the SAD entry */
> + if (cipher_parms->alg) {
> + if (cipher_parms->key_len) {
> + memcpy(ptr, cipher_parms->key_buf,
> + cipher_parms->key_len);
> + ptr += cipher_parms->key_len;
> + buf_len += cipher_parms->key_len;
> + sctx_words += cipher_parms->key_len / 4;
> + }
> +
> + /*
> + * if encrypting then set IV size, use SCTX IV unless no IV
> + * given here
> + */
> + if (cipher_parms->iv_buf && cipher_parms->iv_len) {
> + /* Use SCTX IV */
> + ecf_bits |= SCTX_IV;
> +
> + /* cipher iv provided so put it in here */
> + memcpy(ptr, cipher_parms->iv_buf, cipher_parms->iv_len);
> +
> + ptr += cipher_parms->iv_len;
> + buf_len += cipher_parms->iv_len;
> + sctx_words += cipher_parms->iv_len / 4;
> + }
> + }
> +
> + /*
> + * RFC4543 (GMAC/ESP) requires data to be sent as part of AAD
> + * so we need to override the BDESC parameters.
> + */
> + if (req_opts->is_rfc4543) {
> + if (req_opts->is_inbound)
> + data_size -= hash_parms->digestsize;
> + offset_iv = aead_parms->assoc_size + data_size;
> + cipher_len = 0;
> + cipher_offset = offset_iv;
> + auth_len = cipher_offset + aead_parms->data_pad_len;
> + }
> +
> + /* write in the total sctx length now that we know it */
> + protocol_bits |= sctx_words;
> +
> + /* Endian adjust the SCTX */
> + spuh->sa.proto_flags = cpu_to_be32(protocol_bits);
> + spuh->sa.cipher_flags = cpu_to_be32(cipher_bits);
> + spuh->sa.ecf = cpu_to_be32(ecf_bits);
> +
> + /* === create the BDESC section === */
> + bdesc = (struct BDESC_HEADER *)ptr;
> +
> + bdesc->offset_mac = cpu_to_be16(auth_offset);
> + bdesc->length_mac = cpu_to_be16(auth_len);
> + bdesc->offset_crypto = cpu_to_be16(cipher_offset);
> + bdesc->length_crypto = cpu_to_be16(cipher_len);
> +
> + /*
> + * CCM in SPU-M requires that ICV not be in same 32-bit word as data or
> + * padding. So account for padding as necessary.
> + */
> + if (cipher_parms->mode == CIPHER_MODE_CCM)
> + auth_len += spum_wordalign_padlen(auth_len);
> +
> + bdesc->offset_icv = cpu_to_be16(auth_len);
> + bdesc->offset_iv = cpu_to_be16(offset_iv);
> +
> + ptr += sizeof(struct BDESC_HEADER);
> + buf_len += sizeof(struct BDESC_HEADER);
> +
> + /* === no MFM section === */
> +
> + /* === create the BD section === */
> +
> + /* add the BD header */
> + bd = (struct BD_HEADER *)ptr;
> + bd->size = cpu_to_be16(real_db_size);
> + bd->prev_length = 0;
> +
> + ptr += sizeof(struct BD_HEADER);
> + buf_len += sizeof(struct BD_HEADER);
> +
> + packet_dump(" SPU request header: ", spu_hdr, buf_len);
> +
> + return buf_len;
> +}
> +
> +/**
> + * spum_cipher_req_init() - Build a SPU request message header, up to and
> + * including the BD header.
> + * @spu_hdr: Start of SPU request header (MH)
> + * @cipher_parms: Parameters that describe the cipher request
> + *
> + * Construct the message starting at spu_hdr. Caller should allocate this buffer
> + * in DMA-able memory at least SPU_HEADER_ALLOC_LEN bytes long.
> + *
> + * Return: the length of the SPU header in bytes. 0 if an error occurs.
> + */
> +u16 spum_cipher_req_init(u8 *spu_hdr, struct spu_cipher_parms *cipher_parms)
> +{
> + struct SPUHEADER *spuh;
> + u32 protocol_bits = 0;
> + u32 cipher_bits = 0;
> + u32 ecf_bits = 0;
> + u8 sctx_words = 0;
> + u8 *ptr = spu_hdr;
> +
> + flow_log("%s()\n", __func__);
> + flow_log(" cipher alg:%u mode:%u type %u\n", cipher_parms->alg,
> + cipher_parms->mode, cipher_parms->type);
> + flow_log(" cipher_iv_len: %u\n", cipher_parms->iv_len);
> + flow_log(" key: %d\n", cipher_parms->key_len);
> + flow_dump(" key: ", cipher_parms->key_buf, cipher_parms->key_len);
> +
> + /* starting out: zero the header (plus some) */
> + memset(spu_hdr, 0, sizeof(struct SPUHEADER));
> + ptr += sizeof(struct SPUHEADER);
> +
> + /* format master header word */
> + /* Do not set the next bit even though the datasheet says to */
> + spuh = (struct SPUHEADER *)spu_hdr;
> +
> + spuh->mh.op_code = SPU_CRYPTO_OPERATION_GENERIC;
> + spuh->mh.flags |= (MH_SCTX_PRES | MH_BDESC_PRES | MH_BD_PRES);
> +
> + /* Format sctx word 0 (protocol_bits) */
> + sctx_words = 3; /* size in words */
> +
> + /* copy the encryption keys in the SAD entry */
> + if (cipher_parms->alg) {
> + if (cipher_parms->key_len) {
> + ptr += cipher_parms->key_len;
> + sctx_words += cipher_parms->key_len / 4;
> + }
> +
> + /*
> + * if encrypting then set IV size, use SCTX IV unless no IV
> + * given here
> + */
> + if (cipher_parms->iv_len) {
> + /* Use SCTX IV */
> + ecf_bits |= SCTX_IV;
> + ptr += cipher_parms->iv_len;
> + sctx_words += cipher_parms->iv_len / 4;
> + }
> + }
> +
> + /* Set the crypto parameters in the cipher.flags */
> + cipher_bits |= cipher_parms->alg << CIPHER_ALG_SHIFT;
> + cipher_bits |= cipher_parms->mode << CIPHER_MODE_SHIFT;
> + cipher_bits |= cipher_parms->type << CIPHER_TYPE_SHIFT;
> +
> + /* copy the encryption keys in the SAD entry */
> + if (cipher_parms->alg && cipher_parms->key_len)
> + memcpy(spuh + 1, cipher_parms->key_buf, cipher_parms->key_len);
> +
> + /* write in the total sctx length now that we know it */
> + protocol_bits |= sctx_words;
> +
> + /* Endian adjust the SCTX */
> + spuh->sa.proto_flags = cpu_to_be32(protocol_bits);
> +
> + /* Endian adjust the SCTX */
> + spuh->sa.cipher_flags = cpu_to_be32(cipher_bits);
> + spuh->sa.ecf = cpu_to_be32(ecf_bits);
> +
> + packet_dump(" SPU request header: ", spu_hdr,
> + sizeof(struct SPUHEADER));
> +
> + return sizeof(struct SPUHEADER) + cipher_parms->key_len +
> + cipher_parms->iv_len + sizeof(struct BDESC_HEADER) +
> + sizeof(struct BD_HEADER);
> +}
> +
> +/**
> + * spum_cipher_req_finish() - Finish building a SPU request message header for a
> + * block cipher request. Assumes much of the header was already filled in at
> + * setkey() time in spu_cipher_req_init().
> + * @spu_hdr: Start of the request message header (MH field)
> + * @spu_req_hdr_len: Length in bytes of the SPU request header
> + * @isInbound: 0 encrypt, 1 decrypt
> + * @cipher_parms: Parameters describing cipher operation to be performed
> + * @update_key: If true, rewrite the cipher key in SCTX
> + * @data_size: Length of the data in the BD field
> + *
> + * Assumes much of the header was already filled in at setkey() time in
> + * spum_cipher_req_init().
> + * spum_cipher_req_init() fills in the encryption key. For RC4, when submitting
> + * a request for a non-first chunk, we use the 260-byte SUPDT field from the
> + * previous response as the key. update_key is true for this case. Unused in all
> + * other cases.
> + */
> +void spum_cipher_req_finish(u8 *spu_hdr,
> + u16 spu_req_hdr_len,
> + unsigned int is_inbound,
> + struct spu_cipher_parms *cipher_parms,
> + bool update_key,
> + unsigned int data_size)
> +{
> + struct SPUHEADER *spuh;
> + struct BDESC_HEADER *bdesc;
> + struct BD_HEADER *bd;
> + u8 *bdesc_ptr = spu_hdr + spu_req_hdr_len -
> + (sizeof(struct BD_HEADER) + sizeof(struct BDESC_HEADER));
> +
> + u32 cipher_bits;
> +
> + flow_log("%s()\n", __func__);
> + flow_log(" in: %u\n", is_inbound);
> + flow_log(" cipher alg: %u, cipher_type: %u\n", cipher_parms->alg,
> + cipher_parms->type);
> + if (update_key) {
> + flow_log(" cipher key len: %u\n", cipher_parms->key_len);
> + flow_dump(" key: ", cipher_parms->key_buf,
> + cipher_parms->key_len);
> + }
> +
> + /*
> + * In XTS mode, API puts "i" parameter (block tweak) in IV. For
> + * SPU-M, should be in start of the BD; tx_sg_create() copies it there.
> + * IV in SPU msg for SPU-M should be 0, since that's the "j" parameter
> + * (block ctr within larger data unit) - given we can send entire disk
> + * block (<= 4KB) in 1 SPU msg, don't need to use this parameter.
> + */
> + if (cipher_parms->mode == CIPHER_MODE_XTS)
> + memset(cipher_parms->iv_buf, 0, cipher_parms->iv_len);
> +
> + flow_log(" iv len: %d\n", cipher_parms->iv_len);
> + flow_dump(" iv: ", cipher_parms->iv_buf, cipher_parms->iv_len);
> + flow_log(" data_size: %u\n", data_size);
> +
> + /* format master header word */
> + /* Do not set the next bit even though the datasheet says to */
> + spuh = (struct SPUHEADER *)spu_hdr;
> +
> + /* cipher_bits was initialized at setkey time */
> + cipher_bits = be32_to_cpu(spuh->sa.cipher_flags);
> +
> + /* Format sctx word 1 (cipher_bits) */
> + if (is_inbound)
> + cipher_bits |= CIPHER_INBOUND;
> + else
> + cipher_bits &= ~CIPHER_INBOUND;
> +
> + /* update encryption key for RC4 on non-first chunk */
> + if (update_key) {
> + spuh->sa.cipher_flags |=
> + cipher_parms->type << CIPHER_TYPE_SHIFT;
> + memcpy(spuh + 1, cipher_parms->key_buf, cipher_parms->key_len);
> + }
> +
> + if (cipher_parms->alg && cipher_parms->iv_buf && cipher_parms->iv_len)
> + /* cipher iv provided so put it in here */
> + memcpy(bdesc_ptr - cipher_parms->iv_len, cipher_parms->iv_buf,
> + cipher_parms->iv_len);
> +
> + spuh->sa.cipher_flags = cpu_to_be32(cipher_bits);
> +
> + /* === create the BDESC section === */
> + bdesc = (struct BDESC_HEADER *)bdesc_ptr;
> + bdesc->offset_mac = 0;
> + bdesc->length_mac = 0;
> + bdesc->offset_crypto = 0;
> +
> + /* XTS mode, data_size needs to include tweak parameter */
> + if (cipher_parms->mode == CIPHER_MODE_XTS)
> + bdesc->length_crypto = cpu_to_be16(data_size +
> + SPU_XTS_TWEAK_SIZE);
> + else
> + bdesc->length_crypto = cpu_to_be16(data_size);
> +
> + bdesc->offset_icv = 0;
> + bdesc->offset_iv = 0;
> +
> + /* === no MFM section === */
> +
> + /* === create the BD section === */
> + /* add the BD header */
> + bd = (struct BD_HEADER *)(bdesc_ptr + sizeof(struct BDESC_HEADER));
> + bd->size = cpu_to_be16(data_size);
> +
> + /* XTS mode, data_size needs to include tweak parameter */
> + if (cipher_parms->mode == CIPHER_MODE_XTS)
> + bd->size = cpu_to_be16(data_size + SPU_XTS_TWEAK_SIZE);
> + else
> + bd->size = cpu_to_be16(data_size);
> +
> + bd->prev_length = 0;
> +
> + packet_dump(" SPU request header: ", spu_hdr, spu_req_hdr_len);
> +}
> +
> +/**
> + * spum_request_pad() - Create pad bytes at the end of the data.
> + * @pad_start: Start of buffer where pad bytes are to be written
> + * @gcm_ccm_padding: length of GCM/CCM padding, in bytes
> + * @hash_pad_len: Number of bytes of padding extend data to full block
> + * @auth_alg: authentication algorithm
> + * @auth_mode: authentication mode
> + * @total_sent: length inserted at end of hash pad
> + * @status_padding: Number of bytes of padding to align STATUS word
> + *
> + * There may be three forms of pad:
> + * 1. GCM/CCM pad - for GCM/CCM mode ciphers, pad to 16-byte alignment
> + * 2. hash pad - pad to a block length, with 0x80 data terminator and
> + * size at the end
> + * 3. STAT pad - to ensure the STAT field is 4-byte aligned
> + */
> +void spum_request_pad(u8 *pad_start,
> + u32 gcm_ccm_padding,
> + u32 hash_pad_len,
> + enum hash_alg auth_alg,
> + enum hash_mode auth_mode,
> + unsigned int total_sent, u32 status_padding)
> +{
> + u8 *ptr = pad_start;
> +
> + /* fix data alignent for GCM/CCM */
> + if (gcm_ccm_padding > 0) {
> + flow_log(" GCM: padding to 16 byte alignment: %u bytes\n",
> + gcm_ccm_padding);
> + memset(ptr, 0, gcm_ccm_padding);
> + ptr += gcm_ccm_padding;
> + }
> +
> + if (hash_pad_len > 0) {
> + /* clear the padding section */
> + memset(ptr, 0, hash_pad_len);
> +
> + if ((auth_alg == HASH_ALG_AES) &&
> + (auth_mode == HASH_MODE_XCBC)) {
> + /* AES/XCBC just requires padding to be 0s */
> + ptr += hash_pad_len;
> + } else {
> + /* terminate the data */
> + *ptr = 0x80;
> + ptr += (hash_pad_len - sizeof(u64));
> +
> + /* add the size at the end as required per alg */
> + if (auth_alg == HASH_ALG_MD5)
> + *(u64 *)ptr = cpu_to_le64((u64)total_sent * 8);
> + else /* SHA1, SHA2-224, SHA2-256 */
> + *(u64 *)ptr = cpu_to_be64((u64)total_sent * 8);
> + ptr += sizeof(u64);
> + }
> + }
> +
> + /* pad to a 4byte alignment for STAT */
> + if (status_padding > 0) {
> + flow_log(" STAT: padding to 4 byte alignment: %u bytes\n",
> + status_padding);
> +
> + memset(ptr, 0, status_padding);
> + ptr += status_padding;
> + }
> +}
> +
> +/**
> + * spum_xts_tweak_in_payload() - Indicate that SPUM DOES place the XTS tweak
> + * field in the packet payload (rather than using IV)
> + *
> + * Return: 1
> + */
> +u8 spum_xts_tweak_in_payload(void)
> +{
> + return 1;
> +}
> +
> +/**
> + * spum_tx_status_len() - Return the length of the STATUS field in a SPU
> + * response message.
> + *
> + * Return: Length of STATUS field in bytes.
> + */
> +u8 spum_tx_status_len(void)
> +{
> + return SPU_TX_STATUS_LEN;
> +}
> +
> +/**
> + * spum_rx_status_len() - Return the length of the STATUS field in a SPU
> + * response message.
> + *
> + * Return: Length of STATUS field in bytes.
> + */
> +u8 spum_rx_status_len(void)
> +{
> + return SPU_RX_STATUS_LEN;
> +}
> +
> +/**
> + * spum_status_process() - Process the status from a SPU response message.
> + * @statp: start of STATUS word
> + * Return:
> + * 0 - if status is good and response should be processed
> + * !0 - status indicates an error and response is invalid
> + */
> +int spum_status_process(u8 *statp)
> +{
> + u32 status;
> +
> + status = __be32_to_cpu(*(__be32 *)statp);
> + flow_log("SPU response STATUS %#08x\n", status);
> + if (status & SPU_STATUS_ERROR_FLAG) {
> + pr_err("%s() Warning: Error result from SPU: %#08x\n",
> + __func__, status);
> + if (status & SPU_STATUS_INVALID_ICV)
> + return SPU_INVALID_ICV;
> + return -EBADMSG;
> + }
> + return 0;
> +}
> +
> +/**
> + * spum_ccm_update_iv() - Update the IV as per the requirements for CCM mode.
> + *
> + * @digestsize: Digest size of this request
> + * @cipher_parms: (pointer to) cipher parmaeters, includes IV buf & IV len
> + * @assoclen: Length of AAD data
> + * @chunksize: length of input data to be sent in this req
> + * @is_encrypt: true if this is an output/encrypt operation
> + * @is_esp: true if this is an ESP / RFC4309 operation
> + *
> + */
> +void spum_ccm_update_iv(unsigned int digestsize,
> + struct spu_cipher_parms *cipher_parms,
> + unsigned int assoclen,
> + unsigned int chunksize,
> + bool is_encrypt,
> + bool is_esp)
> +{
> + u8 L; /* L from CCM algorithm, length of plaintext data */
> + u8 mprime; /* M' from CCM algo, (M - 2) / 2, where M=authsize */
> + u8 adata;
> +
> + if (cipher_parms->iv_len != CCM_AES_IV_SIZE) {
> + pr_err("%s(): Invalid IV len %d for CCM mode, should be %d\n",
> + __func__, cipher_parms->iv_len, CCM_AES_IV_SIZE);
> + return;
> + }
> +
> + /*
> + * IV needs to be formatted as follows:
> + *
> + * | Byte 0 | Bytes 1 - N | Bytes (N+1) - 15 |
> + * | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 | Bits 7 - 0 | Bits 7 - 0 |
> + * | 0 |Ad?|(M - 2) / 2| L - 1 | Nonce | Plaintext Length |
> + *
> + * Ad? = 1 if AAD present, 0 if not present
> + * M = size of auth field, 8, 12, or 16 bytes (SPU-M) -or-
> + * 4, 6, 8, 10, 12, 14, 16 bytes (SPU2)
> + * L = Size of Plaintext Length field; Nonce size = 15 - L
> + *
> + * It appears that the crypto API already expects the L-1 portion
> + * to be set in the first byte of the IV, which implicitly determines
> + * the nonce size, and also fills in the nonce. But the other bits
> + * in byte 0 as well as the plaintext length need to be filled in.
> + *
> + * In rfc4309/esp mode, L is not already in the supplied IV and
> + * we need to fill it in, as well as move the IV data to be after
> + * the salt
> + */
> + if (is_esp) {
> + L = CCM_ESP_L_VALUE; /* RFC4309 has fixed L */
> + } else {
> + /* L' = plaintext length - 1 so Plaintext length is L' + 1 */
> + L = ((cipher_parms->iv_buf[0] & CCM_B0_L_PRIME) >>
> + CCM_B0_L_PRIME_SHIFT) + 1;
> + }
> +
> + mprime = (digestsize - 2) >> 1; /* M' = (M - 2) / 2 */
> + adata = (assoclen > 0); /* adata = 1 if any associated data */
> +
> + cipher_parms->iv_buf[0] = (adata << CCM_B0_ADATA_SHIFT) |
> + (mprime << CCM_B0_M_PRIME_SHIFT) |
> + ((L - 1) << CCM_B0_L_PRIME_SHIFT);
> +
> + /* Nonce is already filled in by crypto API, and is 15 - L bytes */
> +
> + /* Don't include digest in plaintext size when decrypting */
> + if (!is_encrypt)
> + chunksize -= digestsize;
> +
> + /* Fill in length of plaintext, formatted to be L bytes long */
> + format_value_ccm(chunksize, &cipher_parms->iv_buf[15 - L + 1], L);
> +}
> +
> +/**
> + * spum_wordalign_padlen() - Given the length of a data field, determine the
> + * padding required to align the data following this field on a 4-byte boundary.
> + * @data_size: length of data field in bytes
> + *
> + * Return: length of status field padding, in bytes
> + */
> +u32 spum_wordalign_padlen(u32 data_size)
> +{
> + return ((data_size + 3) & ~3) - data_size;
> +}
> diff --git a/drivers/crypto/bcm/spu.h b/drivers/crypto/bcm/spu.h
> new file mode 100644
> index 0000000..e2eb925
> --- /dev/null
> +++ b/drivers/crypto/bcm/spu.h
> @@ -0,0 +1,288 @@
> +/*
> + * Copyright 2016 Broadcom
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License, version 2, as
> + * published by the Free Software Foundation (the "GPL").
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * General Public License version 2 (GPLv2) for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * version 2 (GPLv2) along with this source code.
> + */
> +
> +/*
> + * This file contains the definition of SPU messages. There are currently two
> + * SPU message formats: SPU-M and SPU2. The hardware uses different values to
> + * identify the same things in SPU-M vs SPU2. So this file defines values that
> + * are hardware independent. Software can use these values for any version of
> + * SPU hardware. These values are used in APIs in spu.c. Functions internal to
> + * spu.c and spu2.c convert these to hardware-specific values.
> + */
> +
> +#ifndef _SPU_H
> +#define _SPU_H
> +
> +#include <linux/types.h>
> +#include <linux/scatterlist.h>
> +#include <crypto/sha.h>
> +
> +enum spu_cipher_alg {
> + CIPHER_ALG_NONE = 0x0,
> + CIPHER_ALG_RC4 = 0x1,
> + CIPHER_ALG_DES = 0x2,
> + CIPHER_ALG_3DES = 0x3,
> + CIPHER_ALG_AES = 0x4,
> + CIPHER_ALG_LAST = 0x5
> +};
> +
> +enum spu_cipher_mode {
> + CIPHER_MODE_NONE = 0x0,
> + CIPHER_MODE_ECB = 0x0,
> + CIPHER_MODE_CBC = 0x1,
> + CIPHER_MODE_OFB = 0x2,
> + CIPHER_MODE_CFB = 0x3,
> + CIPHER_MODE_CTR = 0x4,
> + CIPHER_MODE_CCM = 0x5,
> + CIPHER_MODE_GCM = 0x6,
> + CIPHER_MODE_XTS = 0x7,
> + CIPHER_MODE_LAST = 0x8
> +};
> +
> +enum spu_cipher_type {
> + CIPHER_TYPE_NONE = 0x0,
> + CIPHER_TYPE_DES = 0x0,
> + CIPHER_TYPE_3DES = 0x0,
> + CIPHER_TYPE_INIT = 0x0, /* used for ARC4 */
> + CIPHER_TYPE_AES128 = 0x0,
> + CIPHER_TYPE_AES192 = 0x1,
> + CIPHER_TYPE_UPDT = 0x1, /* used for ARC4 */
> + CIPHER_TYPE_AES256 = 0x2,
> +};
> +
> +enum hash_alg {
> + HASH_ALG_NONE = 0x0,
> + HASH_ALG_MD5 = 0x1,
> + HASH_ALG_SHA1 = 0x2,
> + HASH_ALG_SHA224 = 0x3,
> + HASH_ALG_SHA256 = 0x4,
> + HASH_ALG_AES = 0x5,
> + HASH_ALG_SHA384 = 0x6,
> + HASH_ALG_SHA512 = 0x7,
> + /* Keep SHA3 algorithms at the end always */
> + HASH_ALG_SHA3_224 = 0x8,
> + HASH_ALG_SHA3_256 = 0x9,
> + HASH_ALG_SHA3_384 = 0xa,
> + HASH_ALG_SHA3_512 = 0xb,
> + HASH_ALG_LAST
> +};
> +
> +enum hash_mode {
> + HASH_MODE_NONE = 0x0,
> + HASH_MODE_HASH = 0x0,
> + HASH_MODE_XCBC = 0x0,
> + HASH_MODE_CMAC = 0x1,
> + HASH_MODE_CTXT = 0x1,
> + HASH_MODE_HMAC = 0x2,
> + HASH_MODE_RABIN = 0x4,
> + HASH_MODE_FHMAC = 0x6,
> + HASH_MODE_CCM = 0x5,
> + HASH_MODE_GCM = 0x6,
> +};
> +
> +enum hash_type {
> + HASH_TYPE_NONE = 0x0,
> + HASH_TYPE_FULL = 0x0,
> + HASH_TYPE_INIT = 0x1,
> + HASH_TYPE_UPDT = 0x2,
> + HASH_TYPE_FIN = 0x3,
> + HASH_TYPE_AES128 = 0x0,
> + HASH_TYPE_AES192 = 0x1,
> + HASH_TYPE_AES256 = 0x2
> +};
> +
> +enum aead_type {
> + AES_CCM,
> + AES_GCM,
> + AUTHENC,
> + AEAD_TYPE_LAST
> +};
> +
> +extern char *hash_alg_name[HASH_ALG_LAST];
> +extern char *aead_alg_name[AEAD_TYPE_LAST];
> +
> +struct spu_request_opts {
> + bool is_inbound;
> + bool auth_first;
> + bool is_aead;
> + bool is_esp;
> + bool bd_suppress;
> + bool is_rfc4543;
> +};
> +
> +struct spu_cipher_parms {
> + enum spu_cipher_alg alg;
> + enum spu_cipher_mode mode;
> + enum spu_cipher_type type;
> + u8 *key_buf;
> + u16 key_len;
> + /* iv_buf and iv_len include salt, if applicable */
> + u8 *iv_buf;
> + u16 iv_len;
> +};
> +
> +struct spu_hash_parms {
> + enum hash_alg alg;
> + enum hash_mode mode;
> + enum hash_type type;
> + u8 digestsize;
> + u8 *key_buf;
> + u16 key_len;
> + u16 prebuf_len;
> + u16 hmac_offset;
> + /* length of hash pad. signed, needs to handle roll-overs */
> + int pad_len;
> +};
> +
> +struct spu_aead_parms {
> + u32 assoc_size;
> + u16 iv_len; /* length of IV field between assoc data and data */
> + u8 aad_pad_len; /* For AES GCM/CCM, length of padding after AAD */
> + u8 data_pad_len;/* For AES GCM/CCM, length of padding after data */
> + bool return_iv; /* True if SPU should return an IV */
> + u32 ret_iv_len; /* Length in bytes of returned IV */
> + u32 ret_iv_off; /* Offset into full IV if partial IV returned */
> +};
> +
> +/************** SPU sizes ***************/
> +
> +#define SPU_RX_STATUS_LEN 4
> +
> +/* Max length of padding for 4-byte alignment of STATUS field */
> +#define SPU_STAT_PAD_MAX 4
> +
> +/* Max length of pad fragment. 4 is for 4-byte alignment of STATUS field */
> +#define SPU_PAD_LEN_MAX (SPU_GCM_CCM_ALIGN + MAX_HASH_BLOCK_SIZE + \
> + SPU_STAT_PAD_MAX)
> +
> +/* GCM and CCM require 16-byte alignment */
> +#define SPU_GCM_CCM_ALIGN 16
> +
> +/* Length up SUPDT field in SPU response message for RC4 */
> +#define SPU_SUPDT_LEN 260
> +
> +/* SPU status error codes. These used as common error codes across all
> + * SPU variants.
> + */
> +#define SPU_INVALID_ICV 1
> +
> +/* Indicates no limit to the length of the payload in a SPU message */
> +#define SPU_MAX_PAYLOAD_INF 0xFFFFFFFF
> +
> +/* Size of XTS tweak ("i" parameter), in bytes */
> +#define SPU_XTS_TWEAK_SIZE 16
> +
> +/* CCM B_0 field definitions, common for SPU-M and SPU2 */
> +#define CCM_B0_ADATA 0x40
> +#define CCM_B0_ADATA_SHIFT 6
> +#define CCM_B0_M_PRIME 0x38
> +#define CCM_B0_M_PRIME_SHIFT 3
> +#define CCM_B0_L_PRIME 0x07
> +#define CCM_B0_L_PRIME_SHIFT 0
> +#define CCM_ESP_L_VALUE 4
> +
> +/**
> + * spu_req_incl_icv() - Return true if SPU request message should include the
> + * ICV as a separate buffer.
> + * @cipher_mode: the cipher mode being requested
> + * @is_encrypt: true if encrypting. false if decrypting.
> + *
> + * Return: true if ICV to be included as separate buffer
> + */
> +static __always_inline bool spu_req_incl_icv(enum spu_cipher_mode cipher_mode,
> + bool is_encrypt)
> +{
> + if ((cipher_mode == CIPHER_MODE_GCM) && !is_encrypt)
> + return true;
> + if ((cipher_mode == CIPHER_MODE_CCM) && !is_encrypt)
> + return true;
> +
> + return false;
> +}
> +
> +static __always_inline u32 spu_real_db_size(u32 assoc_size,
> + u32 aead_iv_buf_len,
> + u32 prebuf_len,
> + u32 data_size,
> + u32 aad_pad_len,
> + u32 gcm_pad_len,
> + u32 hash_pad_len)
> +{
> + return assoc_size + aead_iv_buf_len + prebuf_len + data_size +
> + aad_pad_len + gcm_pad_len + hash_pad_len;
> +}
> +
> +/************** SPU Functions Prototypes **************/
> +
> +void spum_dump_msg_hdr(u8 *buf, unsigned int buf_len);
> +
> +u32 spum_ns2_ctx_max_payload(enum spu_cipher_alg cipher_alg,
> + enum spu_cipher_mode cipher_mode,
> + unsigned int blocksize);
> +u32 spum_nsp_ctx_max_payload(enum spu_cipher_alg cipher_alg,
> + enum spu_cipher_mode cipher_mode,
> + unsigned int blocksize);
> +u32 spum_payload_length(u8 *spu_hdr);
> +u16 spum_response_hdr_len(u16 auth_key_len, u16 enc_key_len, bool is_hash);
> +u16 spum_hash_pad_len(enum hash_alg hash_alg, enum hash_mode hash_mode,
> + u32 chunksize, u16 hash_block_size);
> +u32 spum_gcm_ccm_pad_len(enum spu_cipher_mode cipher_mode,
> + unsigned int data_size);
> +u32 spum_assoc_resp_len(enum spu_cipher_mode cipher_mode,
> + unsigned int assoc_len, unsigned int iv_len,
> + bool is_encrypt);
> +u8 spum_aead_ivlen(enum spu_cipher_mode cipher_mode, u16 iv_len);
> +bool spu_req_incl_icv(enum spu_cipher_mode cipher_mode, bool is_encrypt);
> +enum hash_type spum_hash_type(u32 src_sent);
> +u32 spum_digest_size(u32 alg_digest_size, enum hash_alg alg,
> + enum hash_type htype);
> +
> +u32 spum_create_request(u8 *spu_hdr,
> + struct spu_request_opts *req_opts,
> + struct spu_cipher_parms *cipher_parms,
> + struct spu_hash_parms *hash_parms,
> + struct spu_aead_parms *aead_parms,
> + unsigned int data_size);
> +
> +u16 spum_cipher_req_init(u8 *spu_hdr, struct spu_cipher_parms *cipher_parms);
> +
> +void spum_cipher_req_finish(u8 *spu_hdr,
> + u16 spu_req_hdr_len,
> + unsigned int is_inbound,
> + struct spu_cipher_parms *cipher_parms,
> + bool update_key,
> + unsigned int data_size);
> +
> +void spum_request_pad(u8 *pad_start,
> + u32 gcm_padding,
> + u32 hash_pad_len,
> + enum hash_alg auth_alg,
> + enum hash_mode auth_mode,
> + unsigned int total_sent, u32 status_padding);
> +
> +u8 spum_xts_tweak_in_payload(void);
> +u8 spum_tx_status_len(void);
> +u8 spum_rx_status_len(void);
> +int spum_status_process(u8 *statp);
> +
> +void spum_ccm_update_iv(unsigned int digestsize,
> + struct spu_cipher_parms *cipher_parms,
> + unsigned int assoclen,
> + unsigned int chunksize,
> + bool is_encrypt,
> + bool is_esp);
> +u32 spum_wordalign_padlen(u32 data_size);
> +#endif
> diff --git a/drivers/crypto/bcm/spu2.c b/drivers/crypto/bcm/spu2.c
> new file mode 100644
> index 0000000..d7b44b6
> --- /dev/null
> +++ b/drivers/crypto/bcm/spu2.c
> @@ -0,0 +1,1402 @@
> +/*
> + * Copyright 2016 Broadcom
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License, version 2, as
> + * published by the Free Software Foundation (the "GPL").
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * General Public License version 2 (GPLv2) for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * version 2 (GPLv2) along with this source code.
> + */
> +
> +/*
> + * This file works with the SPU2 version of the SPU. SPU2 has different message
> + * formats than the previous version of the SPU. All SPU message format
> + * differences should be hidden in the spux.c,h files.
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/string.h>
> +
> +#include "util.h"
> +#include "spu.h"
> +#include "spu2.h"
> +
> +#define SPU2_TX_STATUS_LEN 0 /* SPU2 has no STATUS in input packet */
> +
> +/*
> + * Controlled by pkt_stat_cnt field in CRYPTO_SS_SPU0_CORE_SPU2_CONTROL0
> + * register. Defaults to 2.
> + */
> +#define SPU2_RX_STATUS_LEN 2
> +
> +enum spu2_proto_sel {
> + SPU2_PROTO_RESV = 0,
> + SPU2_MACSEC_SECTAG8_ECB = 1,
> + SPU2_MACSEC_SECTAG8_SCB = 2,
> + SPU2_MACSEC_SECTAG16 = 3,
> + SPU2_MACSEC_SECTAG16_8_XPN = 4,
> + SPU2_IPSEC = 5,
> + SPU2_IPSEC_ESN = 6,
> + SPU2_TLS_CIPHER = 7,
> + SPU2_TLS_AEAD = 8,
> + SPU2_DTLS_CIPHER = 9,
> + SPU2_DTLS_AEAD = 10
> +};
> +
> +char *spu2_cipher_type_names[] = { "None", "AES128", "AES192", "AES256",
> + "DES", "3DES"
> +};
> +
> +char *spu2_cipher_mode_names[] = { "ECB", "CBC", "CTR", "CFB", "OFB", "XTS",
> + "CCM", "GCM"
> +};
> +
> +char *spu2_hash_type_names[] = { "None", "AES128", "AES192", "AES256",
> + "Reserved", "Reserved", "MD5", "SHA1", "SHA224", "SHA256", "SHA384",
> + "SHA512", "SHA512/224", "SHA512/256", "SHA3-224", "SHA3-256",
> + "SHA3-384", "SHA3-512"
> +};
> +
> +char *spu2_hash_mode_names[] = { "CMAC", "CBC-MAC", "XCBC-MAC", "HMAC",
> + "Rabin", "CCM", "GCM", "Reserved"
> +};
> +
> +static char *spu2_ciph_type_name(enum spu2_cipher_type cipher_type)
> +{
> + if (cipher_type >= SPU2_CIPHER_TYPE_LAST)
> + return "Reserved";
> + return spu2_cipher_type_names[cipher_type];
> +}
> +
> +static char *spu2_ciph_mode_name(enum spu2_cipher_mode cipher_mode)
> +{
> + if (cipher_mode >= SPU2_CIPHER_MODE_LAST)
> + return "Reserved";
> + return spu2_cipher_mode_names[cipher_mode];
> +}
> +
> +static char *spu2_hash_type_name(enum spu2_hash_type hash_type)
> +{
> + if (hash_type >= SPU2_HASH_TYPE_LAST)
> + return "Reserved";
> + return spu2_hash_type_names[hash_type];
> +}
> +
> +static char *spu2_hash_mode_name(enum spu2_hash_mode hash_mode)
> +{
> + if (hash_mode >= SPU2_HASH_MODE_LAST)
> + return "Reserved";
> + return spu2_hash_mode_names[hash_mode];
> +}
> +
> +/*
> + * Convert from a software cipher mode value to the corresponding value
> + * for SPU2.
> + */
> +static int spu2_cipher_mode_xlate(enum spu_cipher_mode cipher_mode,
> + enum spu2_cipher_mode *spu2_mode)
> +{
> + switch (cipher_mode) {
> + case CIPHER_MODE_ECB:
> + *spu2_mode = SPU2_CIPHER_MODE_ECB;
> + break;
> + case CIPHER_MODE_CBC:
> + *spu2_mode = SPU2_CIPHER_MODE_CBC;
> + break;
> + case CIPHER_MODE_OFB:
> + *spu2_mode = SPU2_CIPHER_MODE_OFB;
> + break;
> + case CIPHER_MODE_CFB:
> + *spu2_mode = SPU2_CIPHER_MODE_CFB;
> + break;
> + case CIPHER_MODE_CTR:
> + *spu2_mode = SPU2_CIPHER_MODE_CTR;
> + break;
> + case CIPHER_MODE_CCM:
> + *spu2_mode = SPU2_CIPHER_MODE_CCM;
> + break;
> + case CIPHER_MODE_GCM:
> + *spu2_mode = SPU2_CIPHER_MODE_GCM;
> + break;
> + case CIPHER_MODE_XTS:
> + *spu2_mode = SPU2_CIPHER_MODE_XTS;
> + break;
> + default:
> + return -EINVAL;
> + }
> + return 0;
> +}
> +
> +/**
> + * spu2_cipher_xlate() - Convert a cipher {alg/mode/type} triple to a SPU2
> + * cipher type and mode.
> + * @cipher_alg: [in] cipher algorithm value from software enumeration
> + * @cipher_mode: [in] cipher mode value from software enumeration
> + * @cipher_type: [in] cipher type value from software enumeration
> + * @spu2_type: [out] cipher type value used by spu2 hardware
> + * @spu2_mode: [out] cipher mode value used by spu2 hardware
> + *
> + * Return: 0 if successful
> + */
> +static int spu2_cipher_xlate(enum spu_cipher_alg cipher_alg,
> + enum spu_cipher_mode cipher_mode,
> + enum spu_cipher_type cipher_type,
> + enum spu2_cipher_type *spu2_type,
> + enum spu2_cipher_mode *spu2_mode)
> +{
> + int err;
> +
> + err = spu2_cipher_mode_xlate(cipher_mode, spu2_mode);
> + if (err) {
> + flow_log("Invalid cipher mode %d\n", cipher_mode);
> + return err;
> + }
> +
> + switch (cipher_alg) {
> + case CIPHER_ALG_NONE:
> + *spu2_type = SPU2_CIPHER_TYPE_NONE;
> + break;
> + case CIPHER_ALG_RC4:
> + /* SPU2 does not support RC4 */
> + err = -EINVAL;
> + *spu2_type = SPU2_CIPHER_TYPE_NONE;
> + break;
> + case CIPHER_ALG_DES:
> + *spu2_type = SPU2_CIPHER_TYPE_DES;
> + break;
> + case CIPHER_ALG_3DES:
> + *spu2_type = SPU2_CIPHER_TYPE_3DES;
> + break;
> + case CIPHER_ALG_AES:
> + switch (cipher_type) {
> + case CIPHER_TYPE_AES128:
> + *spu2_type = SPU2_CIPHER_TYPE_AES128;
> + break;
> + case CIPHER_TYPE_AES192:
> + *spu2_type = SPU2_CIPHER_TYPE_AES192;
> + break;
> + case CIPHER_TYPE_AES256:
> + *spu2_type = SPU2_CIPHER_TYPE_AES256;
> + break;
> + default:
> + err = -EINVAL;
> + }
> + break;
> + case CIPHER_ALG_LAST:
> + default:
> + err = -EINVAL;
> + break;
> + }
> +
> + if (err)
> + flow_log("Invalid cipher alg %d or type %d\n",
> + cipher_alg, cipher_type);
> + return err;
> +}
> +
> +/*
> + * Convert from a software hash mode value to the corresponding value
> + * for SPU2. Note that HASH_MODE_NONE and HASH_MODE_XCBC have the same value.
> + */
> +static int spu2_hash_mode_xlate(enum hash_mode hash_mode,
> + enum spu2_hash_mode *spu2_mode)
> +{
> + switch (hash_mode) {
> + case HASH_MODE_XCBC:
> + *spu2_mode = SPU2_HASH_MODE_XCBC_MAC;
> + break;
> + case HASH_MODE_CMAC:
> + *spu2_mode = SPU2_HASH_MODE_CMAC;
> + break;
> + case HASH_MODE_HMAC:
> + *spu2_mode = SPU2_HASH_MODE_HMAC;
> + break;
> + case HASH_MODE_CCM:
> + *spu2_mode = SPU2_HASH_MODE_CCM;
> + break;
> + case HASH_MODE_GCM:
> + *spu2_mode = SPU2_HASH_MODE_GCM;
> + break;
> + default:
> + return -EINVAL;
> + }
> + return 0;
> +}
> +
> +/**
> + * spu2_hash_xlate() - Convert a hash {alg/mode/type} triple to a SPU2 hash type
> + * and mode.
> + * @hash_alg: [in] hash algorithm value from software enumeration
> + * @hash_mode: [in] hash mode value from software enumeration
> + * @hash_type: [in] hash type value from software enumeration
> + * @ciph_type: [in] cipher type value from software enumeration
> + * @spu2_type: [out] hash type value used by SPU2 hardware
> + * @spu2_mode: [out] hash mode value used by SPU2 hardware
> + *
> + * Return: 0 if successful
> + */
> +static int
> +spu2_hash_xlate(enum hash_alg hash_alg, enum hash_mode hash_mode,
> + enum hash_type hash_type, enum spu_cipher_type ciph_type,
> + enum spu2_hash_type *spu2_type, enum spu2_hash_mode *spu2_mode)
> +{
> + int err;
> +
> + err = spu2_hash_mode_xlate(hash_mode, spu2_mode);
> + if (err) {
> + flow_log("Invalid hash mode %d\n", hash_mode);
> + return err;
> + }
> +
> + switch (hash_alg) {
> + case HASH_ALG_NONE:
> + *spu2_type = SPU2_HASH_TYPE_NONE;
> + break;
> + case HASH_ALG_MD5:
> + *spu2_type = SPU2_HASH_TYPE_MD5;
> + break;
> + case HASH_ALG_SHA1:
> + *spu2_type = SPU2_HASH_TYPE_SHA1;
> + break;
> + case HASH_ALG_SHA224:
> + *spu2_type = SPU2_HASH_TYPE_SHA224;
> + break;
> + case HASH_ALG_SHA256:
> + *spu2_type = SPU2_HASH_TYPE_SHA256;
> + break;
> + case HASH_ALG_SHA384:
> + *spu2_type = SPU2_HASH_TYPE_SHA384;
> + break;
> + case HASH_ALG_SHA512:
> + *spu2_type = SPU2_HASH_TYPE_SHA512;
> + break;
> + case HASH_ALG_AES:
> + switch (ciph_type) {
> + case CIPHER_TYPE_AES128:
> + *spu2_type = SPU2_HASH_TYPE_AES128;
> + break;
> + case CIPHER_TYPE_AES192:
> + *spu2_type = SPU2_HASH_TYPE_AES192;
> + break;
> + case CIPHER_TYPE_AES256:
> + *spu2_type = SPU2_HASH_TYPE_AES256;
> + break;
> + default:
> + err = -EINVAL;
> + }
> + break;
> + case HASH_ALG_SHA3_224:
> + *spu2_type = SPU2_HASH_TYPE_SHA3_224;
> + break;
> + case HASH_ALG_SHA3_256:
> + *spu2_type = SPU2_HASH_TYPE_SHA3_256;
> + break;
> + case HASH_ALG_SHA3_384:
> + *spu2_type = SPU2_HASH_TYPE_SHA3_384;
> + break;
> + case HASH_ALG_SHA3_512:
> + *spu2_type = SPU2_HASH_TYPE_SHA3_512;
> + case HASH_ALG_LAST:
> + default:
> + err = -EINVAL;
> + break;
> + }
> +
> + if (err)
> + flow_log("Invalid hash alg %d or type %d\n",
> + hash_alg, hash_type);
> + return err;
> +}
> +
> +/* Dump FMD ctrl0. The ctrl0 input is in host byte order */
> +static void spu2_dump_fmd_ctrl0(u64 ctrl0)
> +{
> + enum spu2_cipher_type ciph_type;
> + enum spu2_cipher_mode ciph_mode;
> + enum spu2_hash_type hash_type;
> + enum spu2_hash_mode hash_mode;
> + char *ciph_name;
> + char *ciph_mode_name;
> + char *hash_name;
> + char *hash_mode_name;
> + u8 cfb;
> + u8 proto;
> +
> + packet_log(" FMD CTRL0 %#16llx\n", ctrl0);
> + if (ctrl0 & SPU2_CIPH_ENCRYPT_EN)
> + packet_log(" encrypt\n");
> + else
> + packet_log(" decrypt\n");
> +
> + ciph_type = (ctrl0 & SPU2_CIPH_TYPE) >> SPU2_CIPH_TYPE_SHIFT;
> + ciph_name = spu2_ciph_type_name(ciph_type);
> + packet_log(" Cipher type: %s\n", ciph_name);
> +
> + if (ciph_type != SPU2_CIPHER_TYPE_NONE) {
> + ciph_mode = (ctrl0 & SPU2_CIPH_MODE) >> SPU2_CIPH_MODE_SHIFT;
> + ciph_mode_name = spu2_ciph_mode_name(ciph_mode);
> + packet_log(" Cipher mode: %s\n", ciph_mode_name);
> + }
> +
> + cfb = (ctrl0 & SPU2_CFB_MASK) >> SPU2_CFB_MASK_SHIFT;
> + packet_log(" CFB %#x\n", cfb);
> +
> + proto = (ctrl0 & SPU2_PROTO_SEL) >> SPU2_PROTO_SEL_SHIFT;
> + packet_log(" protocol %#x\n", proto);
> +
> + if (ctrl0 & SPU2_HASH_FIRST)
> + packet_log(" hash first\n");
> + else
> + packet_log(" cipher first\n");
> +
> + if (ctrl0 & SPU2_CHK_TAG)
> + packet_log(" check tag\n");
> +
> + hash_type = (ctrl0 & SPU2_HASH_TYPE) >> SPU2_HASH_TYPE_SHIFT;
> + hash_name = spu2_hash_type_name(hash_type);
> + packet_log(" Hash type: %s\n", hash_name);
> +
> + if (hash_type != SPU2_HASH_TYPE_NONE) {
> + hash_mode = (ctrl0 & SPU2_HASH_MODE) >> SPU2_HASH_MODE_SHIFT;
> + hash_mode_name = spu2_hash_mode_name(hash_mode);
> + packet_log(" Hash mode: %s\n", hash_mode_name);
> + }
> +
> + if (ctrl0 & SPU2_CIPH_PAD_EN) {
> + packet_log(" Cipher pad: %#2llx\n",
> + (ctrl0 & SPU2_CIPH_PAD) >> SPU2_CIPH_PAD_SHIFT);
> + }
> +}
> +
> +/* Dump FMD ctrl1. The ctrl1 input is in host byte order */
> +static void spu2_dump_fmd_ctrl1(u64 ctrl1)
> +{
> + u8 hash_key_len;
> + u8 ciph_key_len;
> + u8 ret_iv_len;
> + u8 iv_offset;
> + u8 iv_len;
> + u8 hash_tag_len;
> + u8 ret_md;
> +
> + packet_log(" FMD CTRL1 %#16llx\n", ctrl1);
> + if (ctrl1 & SPU2_TAG_LOC)
> + packet_log(" Tag after payload\n");
> +
> + packet_log(" Msg includes ");
> + if (ctrl1 & SPU2_HAS_FR_DATA)
> + packet_log("FD ");
> + if (ctrl1 & SPU2_HAS_AAD1)
> + packet_log("AAD1 ");
> + if (ctrl1 & SPU2_HAS_NAAD)
> + packet_log("NAAD ");
> + if (ctrl1 & SPU2_HAS_AAD2)
> + packet_log("AAD2 ");
> + if (ctrl1 & SPU2_HAS_ESN)
> + packet_log("ESN ");
> + packet_log("\n");
> +
> + hash_key_len = (ctrl1 & SPU2_HASH_KEY_LEN) >> SPU2_HASH_KEY_LEN_SHIFT;
> + packet_log(" Hash key len %u\n", hash_key_len);
> +
> + ciph_key_len = (ctrl1 & SPU2_CIPH_KEY_LEN) >> SPU2_CIPH_KEY_LEN_SHIFT;
> + packet_log(" Cipher key len %u\n", ciph_key_len);
> +
> + if (ctrl1 & SPU2_GENIV)
> + packet_log(" Generate IV\n");
> +
> + if (ctrl1 & SPU2_HASH_IV)
> + packet_log(" IV included in hash\n");
> +
> + if (ctrl1 & SPU2_RET_IV)
> + packet_log(" Return IV in output before payload\n");
> +
> + ret_iv_len = (ctrl1 & SPU2_RET_IV_LEN) >> SPU2_RET_IV_LEN_SHIFT;
> + packet_log(" Length of returned IV %u bytes\n",
> + ret_iv_len ? ret_iv_len : 16);
> +
> + iv_offset = (ctrl1 & SPU2_IV_OFFSET) >> SPU2_IV_OFFSET_SHIFT;
> + packet_log(" IV offset %u\n", iv_offset);
> +
> + iv_len = (ctrl1 & SPU2_IV_LEN) >> SPU2_IV_LEN_SHIFT;
> + packet_log(" Input IV len %u bytes\n", iv_len);
> +
> + hash_tag_len = (ctrl1 & SPU2_HASH_TAG_LEN) >> SPU2_HASH_TAG_LEN_SHIFT;
> + packet_log(" Hash tag length %u bytes\n", hash_tag_len);
> +
> + packet_log(" Return ");
> + ret_md = (ctrl1 & SPU2_RETURN_MD) >> SPU2_RETURN_MD_SHIFT;
> + if (ret_md)
> + packet_log("FMD ");
> + if (ret_md == SPU2_RET_FMD_OMD)
> + packet_log("OMD ");
> + else if (ret_md == SPU2_RET_FMD_OMD_IV)
> + packet_log("OMD IV ");
> + if (ctrl1 & SPU2_RETURN_FD)
> + packet_log("FD ");
> + if (ctrl1 & SPU2_RETURN_AAD1)
> + packet_log("AAD1 ");
> + if (ctrl1 & SPU2_RETURN_NAAD)
> + packet_log("NAAD ");
> + if (ctrl1 & SPU2_RETURN_AAD2)
> + packet_log("AAD2 ");
> + if (ctrl1 & SPU2_RETURN_PAY)
> + packet_log("Payload");
> + packet_log("\n");
> +}
> +
> +/* Dump FMD ctrl2. The ctrl2 input is in host byte order */
> +static void spu2_dump_fmd_ctrl2(u64 ctrl2)
> +{
> + packet_log(" FMD CTRL2 %#16llx\n", ctrl2);
> +
> + packet_log(" AAD1 offset %llu length %llu bytes\n",
> + ctrl2 & SPU2_AAD1_OFFSET,
> + (ctrl2 & SPU2_AAD1_LEN) >> SPU2_AAD1_LEN_SHIFT);
> + packet_log(" AAD2 offset %llu\n",
> + (ctrl2 & SPU2_AAD2_OFFSET) >> SPU2_AAD2_OFFSET_SHIFT);
> + packet_log(" Payload offset %llu\n",
> + (ctrl2 & SPU2_PL_OFFSET) >> SPU2_PL_OFFSET_SHIFT);
> +}
> +
> +/* Dump FMD ctrl3. The ctrl3 input is in host byte order */
> +static void spu2_dump_fmd_ctrl3(u64 ctrl3)
> +{
> + packet_log(" FMD CTRL3 %#16llx\n", ctrl3);
> +
> + packet_log(" Payload length %llu bytes\n", ctrl3 & SPU2_PL_LEN);
> + packet_log(" TLS length %llu bytes\n",
> + (ctrl3 & SPU2_TLS_LEN) >> SPU2_TLS_LEN_SHIFT);
> +}
> +
> +static void spu2_dump_fmd(struct SPU2_FMD *fmd)
> +{
> + spu2_dump_fmd_ctrl0(le64_to_cpu(fmd->ctrl0));
> + spu2_dump_fmd_ctrl1(le64_to_cpu(fmd->ctrl1));
> + spu2_dump_fmd_ctrl2(le64_to_cpu(fmd->ctrl2));
> + spu2_dump_fmd_ctrl3(le64_to_cpu(fmd->ctrl3));
> +}
> +
> +static void spu2_dump_omd(u8 *omd, u16 hash_key_len, u16 ciph_key_len,
> + u16 hash_iv_len, u16 ciph_iv_len)
> +{
> + u8 *ptr = omd;
> +
> + packet_log(" OMD:\n");
> +
> + if (hash_key_len) {
> + packet_log(" Hash Key Length %u bytes\n", hash_key_len);
> + packet_dump(" KEY: ", ptr, hash_key_len);
> + ptr += hash_key_len;
> + }
> +
> + if (ciph_key_len) {
> + packet_log(" Cipher Key Length %u bytes\n", ciph_key_len);
> + packet_dump(" KEY: ", ptr, ciph_key_len);
> + ptr += ciph_key_len;
> + }
> +
> + if (hash_iv_len) {
> + packet_log(" Hash IV Length %u bytes\n", hash_iv_len);
> + packet_dump(" hash IV: ", ptr, hash_iv_len);
> + ptr += ciph_key_len;
> + }
> +
> + if (ciph_iv_len) {
> + packet_log(" Cipher IV Length %u bytes\n", ciph_iv_len);
> + packet_dump(" cipher IV: ", ptr, ciph_iv_len);
> + }
> +}
> +
> +/* Dump a SPU2 header for debug */
> +void spu2_dump_msg_hdr(u8 *buf, unsigned int buf_len)
> +{
> + struct SPU2_FMD *fmd = (struct SPU2_FMD *)buf;
> + u8 *omd;
> + u64 ctrl1;
> + u16 hash_key_len;
> + u16 ciph_key_len;
> + u16 hash_iv_len;
> + u16 ciph_iv_len;
> + u16 omd_len;
> +
> + packet_log("\n");
> + packet_log("SPU2 message header %p len: %u\n", buf, buf_len);
> +
> + spu2_dump_fmd(fmd);
> + omd = (u8 *)(fmd + 1);
> +
> + ctrl1 = le64_to_cpu(fmd->ctrl1);
> + hash_key_len = (ctrl1 & SPU2_HASH_KEY_LEN) >> SPU2_HASH_KEY_LEN_SHIFT;
> + ciph_key_len = (ctrl1 & SPU2_CIPH_KEY_LEN) >> SPU2_CIPH_KEY_LEN_SHIFT;
> + hash_iv_len = 0;
> + ciph_iv_len = (ctrl1 & SPU2_IV_LEN) >> SPU2_IV_LEN_SHIFT;
> + spu2_dump_omd(omd, hash_key_len, ciph_key_len, hash_iv_len,
> + ciph_iv_len);
> +
> + /* Double check sanity */
> + omd_len = hash_key_len + ciph_key_len + hash_iv_len + ciph_iv_len;
> + if (FMD_SIZE + omd_len != buf_len) {
> + packet_log
> + (" Packet parsed incorrectly. buf_len %u, sum of MD %zu\n",
> + buf_len, FMD_SIZE + omd_len);
> + }
> + packet_log("\n");
> +}
> +
> +/**
> + * spu2_fmd_init() - At setkey time, initialize the fixed meta data for
> + * subsequent ablkcipher requests for this context.
> + * @spu2_cipher_type: Cipher algorithm
> + * @spu2_mode: Cipher mode
> + * @cipher_key_len: Length of cipher key, in bytes
> + * @cipher_iv_len: Length of cipher initialization vector, in bytes
> + *
> + * Return: 0 (success)
> + */
> +static int spu2_fmd_init(struct SPU2_FMD *fmd,
> + enum spu2_cipher_type spu2_type,
> + enum spu2_cipher_mode spu2_mode,
> + u32 cipher_key_len, u32 cipher_iv_len)
> +{
> + u64 ctrl0;
> + u64 ctrl1;
> + u64 ctrl2;
> + u64 ctrl3;
> + u32 aad1_offset;
> + u32 aad2_offset;
> + u16 aad1_len = 0;
> + u64 payload_offset;
> +
> + ctrl0 = (spu2_type << SPU2_CIPH_TYPE_SHIFT) |
> + (spu2_mode << SPU2_CIPH_MODE_SHIFT);
> +
> + ctrl1 = (cipher_key_len << SPU2_CIPH_KEY_LEN_SHIFT) |
> + ((u64)cipher_iv_len << SPU2_IV_LEN_SHIFT) |
> + ((u64)SPU2_RET_FMD_ONLY << SPU2_RETURN_MD_SHIFT) | SPU2_RETURN_PAY;
> +
> + /*
> + * AAD1 offset is from start of FD. FD length is always 0 for this
> + * driver. So AAD1_offset is always 0.
> + */
> + aad1_offset = 0;
> + aad2_offset = aad1_offset;
> + payload_offset = 0;
> + ctrl2 = aad1_offset |
> + (aad1_len << SPU2_AAD1_LEN_SHIFT) |
> + (aad2_offset << SPU2_AAD2_OFFSET_SHIFT) |
> + (payload_offset << SPU2_PL_OFFSET_SHIFT);
> +
> + ctrl3 = 0;
> +
> + fmd->ctrl0 = cpu_to_le64(ctrl0);
> + fmd->ctrl1 = cpu_to_le64(ctrl1);
> + fmd->ctrl2 = cpu_to_le64(ctrl2);
> + fmd->ctrl3 = cpu_to_le64(ctrl3);
> +
> + return 0;
> +}
> +
> +/**
> + * spu2_fmd_ctrl0_write() - Write ctrl0 field in fixed metadata (FMD) field of
> + * SPU request packet.
> + * @fmd: Start of FMD field to be written
> + * @is_inbound: true if decrypting. false if encrypting.
> + * @authFirst: true if alg authenticates before encrypting
> + * @protocol: protocol selector
> + * @cipher_type: cipher algorithm
> + * @cipher_mode: cipher mode
> + * @auth_type: authentication type
> + * @auth_mode: authentication mode
> + */
> +static void spu2_fmd_ctrl0_write(struct SPU2_FMD *fmd,
> + bool is_inbound, bool auth_first,
> + enum spu2_proto_sel protocol,
> + enum spu2_cipher_type cipher_type,
> + enum spu2_cipher_mode cipher_mode,
> + enum spu2_hash_type auth_type,
> + enum spu2_hash_mode auth_mode)
> +{
> + u64 ctrl0 = 0;
> +
> + if ((cipher_type != SPU2_CIPHER_TYPE_NONE) && !is_inbound)
> + ctrl0 |= SPU2_CIPH_ENCRYPT_EN;
> +
> + ctrl0 |= ((u64)cipher_type << SPU2_CIPH_TYPE_SHIFT) |
> + ((u64)cipher_mode << SPU2_CIPH_MODE_SHIFT);
> +
> + if (protocol)
> + ctrl0 |= (u64)protocol << SPU2_PROTO_SEL_SHIFT;
> +
> + if (auth_first)
> + ctrl0 |= SPU2_HASH_FIRST;
> +
> + if (is_inbound && (auth_type != SPU2_HASH_TYPE_NONE))
> + ctrl0 |= SPU2_CHK_TAG;
> +
> + ctrl0 |= (((u64)auth_type << SPU2_HASH_TYPE_SHIFT) |
> + ((u64)auth_mode << SPU2_HASH_MODE_SHIFT));
> +
> + fmd->ctrl0 = cpu_to_le64(ctrl0);
> +}
> +
> +/**
> + * spu2_fmd_ctrl1_write() - Write ctrl1 field in fixed metadata (FMD) field of
> + * SPU request packet.
> + * @fmd: Start of FMD field to be written
> + * @assoc_size: Length of additional associated data, in bytes
> + * @auth_key_len: Length of authentication key, in bytes
> + * @cipher_key_len: Length of cipher key, in bytes
> + * @gen_iv: If true, hw generates IV and returns in response
> + * @hash_iv: IV participates in hash. Used for IPSEC and TLS.
> + * @return_iv: Return IV in output packet before payload
> + * @ret_iv_len: Length of IV returned from SPU, in bytes
> + * @ret_iv_offset: Offset into full IV of start of returned IV
> + * @cipher_iv_len: Length of input cipher IV, in bytes
> + * @digest_size: Length of digest (aka, hash tag or ICV), in bytes
> + * @return_payload: Return payload in SPU response
> + * @return_md : return metadata in SPU response
> + *
> + * Packet can have AAD2 w/o AAD1. For algorithms currently supported,
> + * associated data goes in AAD2.
> + */
> +static void spu2_fmd_ctrl1_write(struct SPU2_FMD *fmd, bool is_inbound,
> + u64 assoc_size,
> + u64 auth_key_len, u64 cipher_key_len,
> + bool gen_iv, bool hash_iv, bool return_iv,
> + u64 ret_iv_len, u64 ret_iv_offset,
> + u64 cipher_iv_len, u64 digest_size,
> + bool return_payload, bool return_md)
> +{
> + u64 ctrl1 = 0;
> +
> + if (is_inbound && digest_size)
> + ctrl1 |= SPU2_TAG_LOC;
> +
> + if (assoc_size) {
> + ctrl1 |= SPU2_HAS_AAD2;
> + ctrl1 |= SPU2_RETURN_AAD2; /* need aad2 for gcm aes esp */
> + }
> +
> + if (auth_key_len)
> + ctrl1 |= ((auth_key_len << SPU2_HASH_KEY_LEN_SHIFT) &
> + SPU2_HASH_KEY_LEN);
> +
> + if (cipher_key_len)
> + ctrl1 |= ((cipher_key_len << SPU2_CIPH_KEY_LEN_SHIFT) &
> + SPU2_CIPH_KEY_LEN);
> +
> + if (gen_iv)
> + ctrl1 |= SPU2_GENIV;
> +
> + if (hash_iv)
> + ctrl1 |= SPU2_HASH_IV;
> +
> + if (return_iv) {
> + ctrl1 |= SPU2_RET_IV;
> + ctrl1 |= ret_iv_len << SPU2_RET_IV_LEN_SHIFT;
> + ctrl1 |= ret_iv_offset << SPU2_IV_OFFSET_SHIFT;
> + }
> +
> + ctrl1 |= ((cipher_iv_len << SPU2_IV_LEN_SHIFT) & SPU2_IV_LEN);
> +
> + if (digest_size)
> + ctrl1 |= ((digest_size << SPU2_HASH_TAG_LEN_SHIFT) &
> + SPU2_HASH_TAG_LEN);
> +
> + /* Let's ask for the output pkt to include FMD, but don't need to
> + * get keys and IVs back in OMD.
> + */
> + if (return_md)
> + ctrl1 |= ((u64)SPU2_RET_FMD_ONLY << SPU2_RETURN_MD_SHIFT);
> + else
> + ctrl1 |= ((u64)SPU2_RET_NO_MD << SPU2_RETURN_MD_SHIFT);
> +
> + /* Crypto API does not get assoc data back. So no need for AAD2. */
> +
> + if (return_payload)
> + ctrl1 |= SPU2_RETURN_PAY;
> +
> + fmd->ctrl1 = cpu_to_le64(ctrl1);
> +}
> +
> +/**
> + * spu2_fmd_ctrl2_write() - Set the ctrl2 field in the fixed metadata field of
> + * SPU2 header.
> + * @fmd: Start of FMD field to be written
> + * @cipher_offset: Number of bytes from Start of Packet (end of FD field) where
> + * data to be encrypted or decrypted begins
> + * @auth_key_len: Length of authentication key, in bytes
> + * @auth_iv_len: Length of authentication initialization vector, in bytes
> + * @cipher_key_len: Length of cipher key, in bytes
> + * @cipher_iv_len: Length of cipher IV, in bytes
> + */
> +static void spu2_fmd_ctrl2_write(struct SPU2_FMD *fmd, u64 cipher_offset,
> + u64 auth_key_len, u64 auth_iv_len,
> + u64 cipher_key_len, u64 cipher_iv_len)
> +{
> + u64 ctrl2;
> + u64 aad1_offset;
> + u64 aad2_offset;
> + u16 aad1_len = 0;
> + u64 payload_offset;
> +
> + /* AAD1 offset is from start of FD. FD length always 0. */
> + aad1_offset = 0;
> +
> + aad2_offset = aad1_offset;
> + payload_offset = cipher_offset;
> + ctrl2 = aad1_offset |
> + (aad1_len << SPU2_AAD1_LEN_SHIFT) |
> + (aad2_offset << SPU2_AAD2_OFFSET_SHIFT) |
> + (payload_offset << SPU2_PL_OFFSET_SHIFT);
> +
> + fmd->ctrl2 = cpu_to_le64(ctrl2);
> +}
> +
> +/**
> + * spu2_fmd_ctrl3_write() - Set the ctrl3 field in FMD
> + * @fmd: Fixed meta data. First field in SPU2 msg header.
> + * @payload_len: Length of payload, in bytes
> + */
> +static void spu2_fmd_ctrl3_write(struct SPU2_FMD *fmd, u64 payload_len)
> +{
> + u64 ctrl3;
> +
> + ctrl3 = payload_len & SPU2_PL_LEN;
> +
> + fmd->ctrl3 = cpu_to_le64(ctrl3);
> +}
> +
> +/**
> + * spu2_ctx_max_payload() - Determine the maximum length of the payload for a
> + * SPU message for a given cipher and hash alg context.
> + * @cipher_alg: The cipher algorithm
> + * @cipher_mode: The cipher mode
> + * @blocksize: The size of a block of data for this algo
> + *
> + * For SPU2, the hardware generally ignores the PayloadLen field in ctrl3 of
> + * FMD and just keeps computing until it receives a DMA descriptor with the EOF
> + * flag set. So we consider the max payload to be infinite. AES CCM is an
> + * exception.
> + *
> + * Return: Max payload length in bytes
> + */
> +u32 spu2_ctx_max_payload(enum spu_cipher_alg cipher_alg,
> + enum spu_cipher_mode cipher_mode,
> + unsigned int blocksize)
> +{
> + if ((cipher_alg == CIPHER_ALG_AES) &&
> + (cipher_mode == CIPHER_MODE_CCM)) {
> + u32 excess = SPU2_MAX_PAYLOAD % blocksize;
> +
> + return SPU2_MAX_PAYLOAD - excess;
> + } else {
> + return SPU_MAX_PAYLOAD_INF;
> + }
> +}
> +
> +/**
> + * spu_payload_length() - Given a SPU2 message header, extract the payload
> + * length.
> + * @spu_hdr: Start of SPU message header (FMD)
> + *
> + * Return: payload length, in bytes
> + */
> +u32 spu2_payload_length(u8 *spu_hdr)
> +{
> + struct SPU2_FMD *fmd = (struct SPU2_FMD *)spu_hdr;
> + u32 pl_len;
> + u64 ctrl3;
> +
> + ctrl3 = le64_to_cpu(fmd->ctrl3);
> + pl_len = ctrl3 & SPU2_PL_LEN;
> +
> + return pl_len;
> +}
> +
> +/**
> + * spu_response_hdr_len() - Determine the expected length of a SPU response
> + * header.
> + * @auth_key_len: Length of authentication key, in bytes
> + * @enc_key_len: Length of encryption key, in bytes
> + *
> + * For SPU2, includes just FMD. OMD is never requested.
> + *
> + * Return: Length of FMD, in bytes
> + */
> +u16 spu2_response_hdr_len(u16 auth_key_len, u16 enc_key_len, bool is_hash)
> +{
> + return FMD_SIZE;
> +}
> +
> +/**
> + * spu_hash_pad_len() - Calculate the length of hash padding required to extend
> + * data to a full block size.
> + * @hash_alg: hash algorithm
> + * @hash_mode: hash mode
> + * @chunksize: length of data, in bytes
> + * @hash_block_size: size of a hash block, in bytes
> + *
> + * SPU2 hardware does all hash padding
> + *
> + * Return: length of hash pad in bytes
> + */
> +u16 spu2_hash_pad_len(enum hash_alg hash_alg, enum hash_mode hash_mode,
> + u32 chunksize, u16 hash_block_size)
> +{
> + return 0;
> +}
> +
> +/**
> + * spu2_gcm_ccm_padlen() - Determine the length of GCM/CCM padding for either
> + * the AAD field or the data.
> + *
> + * Return: 0. Unlike SPU-M, SPU2 hardware does any GCM/CCM padding required.
> + */
> +u32 spu2_gcm_ccm_pad_len(enum spu_cipher_mode cipher_mode,
> + unsigned int data_size)
> +{
> + return 0;
> +}
> +
> +/**
> + * spu_assoc_resp_len() - Determine the size of the AAD2 buffer needed to catch
> + * associated data in a SPU2 output packet.
> + * @cipher_mode: cipher mode
> + * @assoc_len: length of additional associated data, in bytes
> + * @iv_len: length of initialization vector, in bytes
> + * @is_encrypt: true if encrypting. false if decrypt.
> + *
> + * Return: Length of buffer to catch associated data in response
> + */
> +u32 spu2_assoc_resp_len(enum spu_cipher_mode cipher_mode,
> + unsigned int assoc_len, unsigned int iv_len,
> + bool is_encrypt)
> +{
> + u32 resp_len = assoc_len;
> +
> + if (is_encrypt)
> + /* gcm aes esp has to write 8-byte IV in response */
> + resp_len += iv_len;
> + return resp_len;
> +}
> +
> +/*
> + * spu_aead_ivlen() - Calculate the length of the AEAD IV to be included
> + * in a SPU request after the AAD and before the payload.
> + * @cipher_mode: cipher mode
> + * @iv_ctr_len: initialization vector length in bytes
> + *
> + * For SPU2, AEAD IV is included in OMD and does not need to be repeated
> + * prior to the payload.
> + *
> + * Return: Length of AEAD IV in bytes
> + */
> +u8 spu2_aead_ivlen(enum spu_cipher_mode cipher_mode, u16 iv_len)
> +{
> + return 0;
> +}
> +
> +/**
> + * spu2_hash_type() - Determine the type of hash operation.
> + * @src_sent: The number of bytes in the current request that have already
> + * been sent to the SPU to be hashed.
> + *
> + * SPU2 always does a FULL hash operation
> + */
> +enum hash_type spu2_hash_type(u32 src_sent)
> +{
> + return HASH_TYPE_FULL;
> +}
> +
> +/**
> + * spu2_digest_size() - Determine the size of a hash digest to expect the SPU to
> + * return.
> + * alg_digest_size: Number of bytes in the final digest for the given algo
> + * alg: The hash algorithm
> + * htype: Type of hash operation (init, update, full, etc)
> + *
> + */
> +u32 spu2_digest_size(u32 alg_digest_size, enum hash_alg alg,
> + enum hash_type htype)
> +{
> + return alg_digest_size;
> +}
> +
> +/**
> + * spu_create_request() - Build a SPU2 request message header, includint FMD and
> + * OMD.
> + * @spu_hdr: Start of buffer where SPU request header is to be written
> + * @req_opts: SPU request message options
> + * @cipher_parms: Parameters related to cipher algorithm
> + * @hash_parms: Parameters related to hash algorithm
> + * @aead_parms: Parameters related to AEAD operation
> + * @data_size: Length of data to be encrypted or authenticated. If AEAD, does
> + * not include length of AAD.
> + *
> + * Construct the message starting at spu_hdr. Caller should allocate this buffer
> + * in DMA-able memory at least SPU_HEADER_ALLOC_LEN bytes long.
> + *
> + * Return: the length of the SPU header in bytes. 0 if an error occurs.
> + */
> +u32 spu2_create_request(u8 *spu_hdr,
> + struct spu_request_opts *req_opts,
> + struct spu_cipher_parms *cipher_parms,
> + struct spu_hash_parms *hash_parms,
> + struct spu_aead_parms *aead_parms,
> + unsigned int data_size)
> +{
> + struct SPU2_FMD *fmd;
> + u8 *ptr;
> + unsigned int buf_len;
> + int err;
> + enum spu2_cipher_type spu2_ciph_type = SPU2_CIPHER_TYPE_NONE;
> + enum spu2_cipher_mode spu2_ciph_mode;
> + enum spu2_hash_type spu2_auth_type = SPU2_HASH_TYPE_NONE;
> + enum spu2_hash_mode spu2_auth_mode;
> + bool return_md = true;
> + enum spu2_proto_sel proto = SPU2_PROTO_RESV;
> +
> + /* size of the payload */
> + unsigned int payload_len =
> + hash_parms->prebuf_len + data_size + hash_parms->pad_len -
> + ((req_opts->is_aead && req_opts->is_inbound) ?
> + hash_parms->digestsize : 0);
> +
> + /* offset of prebuf or data from start of AAD2 */
> + unsigned int cipher_offset = aead_parms->assoc_size +
> + aead_parms->aad_pad_len + aead_parms->iv_len;
> +
> +#ifdef DEBUG
> + /* total size of the data following OMD (without STAT word padding) */
> + unsigned int real_db_size = spu_real_db_size(aead_parms->assoc_size,
> + aead_parms->iv_len,
> + hash_parms->prebuf_len,
> + data_size,
> + aead_parms->aad_pad_len,
> + aead_parms->data_pad_len,
> + hash_parms->pad_len);
> +#endif
> + unsigned int assoc_size = aead_parms->assoc_size;
> +
> + if (req_opts->is_aead &&
> + (cipher_parms->alg == CIPHER_ALG_AES) &&
> + (cipher_parms->mode == CIPHER_MODE_GCM))
> + /*
> + * On SPU 2, aes gcm cipher first on encrypt, auth first on
> + * decrypt
> + */
> + req_opts->auth_first = req_opts->is_inbound;
> +
> + /* and do opposite for ccm (auth 1st on encrypt) */
> + if (req_opts->is_aead &&
> + (cipher_parms->alg == CIPHER_ALG_AES) &&
> + (cipher_parms->mode == CIPHER_MODE_CCM))
> + req_opts->auth_first = !req_opts->is_inbound;
> +
> + flow_log("%s()\n", __func__);
> + flow_log(" in:%u authFirst:%u\n",
> + req_opts->is_inbound, req_opts->auth_first);
> + flow_log(" cipher alg:%u mode:%u type %u\n", cipher_parms->alg,
> + cipher_parms->mode, cipher_parms->type);
> + flow_log(" is_esp: %s\n", req_opts->is_esp ? "yes" : "no");
> + flow_log(" key: %d\n", cipher_parms->key_len);
> + flow_dump(" key: ", cipher_parms->key_buf, cipher_parms->key_len);
> + flow_log(" iv: %d\n", cipher_parms->iv_len);
> + flow_dump(" iv: ", cipher_parms->iv_buf, cipher_parms->iv_len);
> + flow_log(" auth alg:%u mode:%u type %u\n",
> + hash_parms->alg, hash_parms->mode, hash_parms->type);
> + flow_log(" digestsize: %u\n", hash_parms->digestsize);
> + flow_log(" authkey: %d\n", hash_parms->key_len);
> + flow_dump(" authkey: ", hash_parms->key_buf, hash_parms->key_len);
> + flow_log(" assoc_size:%u\n", assoc_size);
> + flow_log(" prebuf_len:%u\n", hash_parms->prebuf_len);
> + flow_log(" data_size:%u\n", data_size);
> + flow_log(" hash_pad_len:%u\n", hash_parms->pad_len);
> + flow_log(" real_db_size:%u\n", real_db_size);
> + flow_log(" cipher_offset:%u payload_len:%u\n",
> + cipher_offset, payload_len);
> + flow_log(" hmac_offset:%u\n", hash_parms->hmac_offset);
> + flow_log(" aead_iv: %u\n", aead_parms->iv_len);
> +
> + /* Convert to spu2 values for cipher alg, hash alg */
> + err = spu2_cipher_xlate(cipher_parms->alg, cipher_parms->mode,
> + cipher_parms->type,
> + &spu2_ciph_type, &spu2_ciph_mode);
> +
> + /* If we are doing GCM hashing only - either via rfc4543 transform
> + * or because we happen to do GCM with AAD only and no payload - we
> + * need to configure hardware to use hash key rather than cipher key
> + * and put data into payload. This is because unlike SPU-M, running
> + * GCM cipher with 0 size payload is not permitted.
> + */
> + if ((req_opts->is_rfc4543) ||
> + ((spu2_ciph_mode == SPU2_CIPHER_MODE_GCM) &&
> + (payload_len == 0))) {
> + /* Use hashing (only) and set up hash key */
> + spu2_ciph_type = SPU2_CIPHER_TYPE_NONE;
> + hash_parms->key_len = cipher_parms->key_len;
> + memcpy(hash_parms->key_buf, cipher_parms->key_buf,
> + cipher_parms->key_len);
> + cipher_parms->key_len = 0;
> +
> + if (req_opts->is_rfc4543)
> + payload_len += assoc_size;
> + else
> + payload_len = assoc_size;
> + cipher_offset = 0;
> + assoc_size = 0;
> + }
> +
> + if (err)
> + return 0;
> +
> + flow_log("spu2 cipher type %s, cipher mode %s\n",
> + spu2_ciph_type_name(spu2_ciph_type),
> + spu2_ciph_mode_name(spu2_ciph_mode));
> +
> + err = spu2_hash_xlate(hash_parms->alg, hash_parms->mode,
> + hash_parms->type,
> + cipher_parms->type,
> + &spu2_auth_type, &spu2_auth_mode);
> + if (err)
> + return 0;
> +
> + flow_log("spu2 hash type %s, hash mode %s\n",
> + spu2_hash_type_name(spu2_auth_type),
> + spu2_hash_mode_name(spu2_auth_mode));
> +
> + fmd = (struct SPU2_FMD *)spu_hdr;
> +
> + spu2_fmd_ctrl0_write(fmd, req_opts->is_inbound, req_opts->auth_first,
> + proto, spu2_ciph_type, spu2_ciph_mode,
> + spu2_auth_type, spu2_auth_mode);
> +
> + spu2_fmd_ctrl1_write(fmd, req_opts->is_inbound, assoc_size,
> + hash_parms->key_len, cipher_parms->key_len,
> + false, false,
> + aead_parms->return_iv, aead_parms->ret_iv_len,
> + aead_parms->ret_iv_off,
> + cipher_parms->iv_len, hash_parms->digestsize,
> + !req_opts->bd_suppress, return_md);
> +
> + spu2_fmd_ctrl2_write(fmd, cipher_offset, hash_parms->key_len, 0,
> + cipher_parms->key_len, cipher_parms->iv_len);
> +
> + spu2_fmd_ctrl3_write(fmd, payload_len);
> +
> + ptr = (u8 *)(fmd + 1);
> + buf_len = sizeof(struct SPU2_FMD);
> +
> + /* Write OMD */
> + if (hash_parms->key_len) {
> + memcpy(ptr, hash_parms->key_buf, hash_parms->key_len);
> + ptr += hash_parms->key_len;
> + buf_len += hash_parms->key_len;
> + }
> + if (cipher_parms->key_len) {
> + memcpy(ptr, cipher_parms->key_buf, cipher_parms->key_len);
> + ptr += cipher_parms->key_len;
> + buf_len += cipher_parms->key_len;
> + }
> + if (cipher_parms->iv_len) {
> + memcpy(ptr, cipher_parms->iv_buf, cipher_parms->iv_len);
> + ptr += cipher_parms->iv_len;
> + buf_len += cipher_parms->iv_len;
> + }
> +
> + packet_dump(" SPU request header: ", spu_hdr, buf_len);
> +
> + return buf_len;
> +}
> +
> +/**
> + * spu_cipher_req_init() - Build an ablkcipher SPU2 request message header,
> + * including FMD and OMD.
> + * @spu_hdr: Location of start of SPU request (FMD field)
> + * @cipher_parms: Parameters describing cipher request
> + *
> + * Called at setkey time to initialize a msg header that can be reused for all
> + * subsequent ablkcipher requests. Construct the message starting at spu_hdr.
> + * Caller should allocate this buffer in DMA-able memory at least
> + * SPU_HEADER_ALLOC_LEN bytes long.
> + *
> + * Return: the total length of the SPU header (FMD and OMD) in bytes. 0 if an
> + * error occurs.
> + */
> +u16 spu2_cipher_req_init(u8 *spu_hdr, struct spu_cipher_parms *cipher_parms)
> +{
> + struct SPU2_FMD *fmd;
> + u8 *omd;
> + enum spu2_cipher_type spu2_type = SPU2_CIPHER_TYPE_NONE;
> + enum spu2_cipher_mode spu2_mode;
> + int err;
> +
> + flow_log("%s()\n", __func__);
> + flow_log(" cipher alg:%u mode:%u type %u\n", cipher_parms->alg,
> + cipher_parms->mode, cipher_parms->type);
> + flow_log(" cipher_iv_len: %u\n", cipher_parms->iv_len);
> + flow_log(" key: %d\n", cipher_parms->key_len);
> + flow_dump(" key: ", cipher_parms->key_buf, cipher_parms->key_len);
> +
> + /* Convert to spu2 values */
> + err = spu2_cipher_xlate(cipher_parms->alg, cipher_parms->mode,
> + cipher_parms->type, &spu2_type, &spu2_mode);
> + if (err)
> + return 0;
> +
> + flow_log("spu2 cipher type %s, cipher mode %s\n",
> + spu2_ciph_type_name(spu2_type),
> + spu2_ciph_mode_name(spu2_mode));
> +
> + /* Construct the FMD header */
> + fmd = (struct SPU2_FMD *)spu_hdr;
> + err = spu2_fmd_init(fmd, spu2_type, spu2_mode, cipher_parms->key_len,
> + cipher_parms->iv_len);
> + if (err)
> + return 0;
> +
> + /* Write cipher key to OMD */
> + omd = (u8 *)(fmd + 1);
> + if (cipher_parms->key_buf && cipher_parms->key_len)
> + memcpy(omd, cipher_parms->key_buf, cipher_parms->key_len);
> +
> + packet_dump(" SPU request header: ", spu_hdr,
> + FMD_SIZE + cipher_parms->key_len + cipher_parms->iv_len);
> +
> + return FMD_SIZE + cipher_parms->key_len + cipher_parms->iv_len;
> +}
> +
> +/**
> + * spu_cipher_req_finish() - Finish building a SPU request message header for a
> + * block cipher request.
> + * @spu_hdr: Start of the request message header (MH field)
> + * @spu_req_hdr_len: Length in bytes of the SPU request header
> + * @isInbound: 0 encrypt, 1 decrypt
> + * @cipher_parms: Parameters describing cipher operation to be performed
> + * @update_key: If true, rewrite the cipher key in SCTX
> + * @data_size: Length of the data in the BD field
> + *
> + * Assumes much of the header was already filled in at setkey() time in
> + * spu_cipher_req_init().
> + * spu_cipher_req_init() fills in the encryption key. For RC4, when submitting a
> + * request for a non-first chunk, we use the 260-byte SUPDT field from the
> + * previous response as the key. update_key is true for this case. Unused in all
> + * other cases.
> + */
> +void spu2_cipher_req_finish(u8 *spu_hdr,
> + u16 spu_req_hdr_len,
> + unsigned int is_inbound,
> + struct spu_cipher_parms *cipher_parms,
> + bool update_key,
> + unsigned int data_size)
> +{
> + struct SPU2_FMD *fmd;
> + u8 *omd; /* start of optional metadata */
> + u64 ctrl0;
> + u64 ctrl3;
> +
> + flow_log("%s()\n", __func__);
> + flow_log(" in: %u\n", is_inbound);
> + flow_log(" cipher alg: %u, cipher_type: %u\n", cipher_parms->alg,
> + cipher_parms->type);
> + if (update_key) {
> + flow_log(" cipher key len: %u\n", cipher_parms->key_len);
> + flow_dump(" key: ", cipher_parms->key_buf,
> + cipher_parms->key_len);
> + }
> + flow_log(" iv len: %d\n", cipher_parms->iv_len);
> + flow_dump(" iv: ", cipher_parms->iv_buf, cipher_parms->iv_len);
> + flow_log(" data_size: %u\n", data_size);
> +
> + fmd = (struct SPU2_FMD *)spu_hdr;
> + omd = (u8 *)(fmd + 1);
> +
> + /*
> + * FMD ctrl0 was initialized at setkey time. update it to indicate
> + * whether we are encrypting or decrypting.
> + */
> + ctrl0 = le64_to_cpu(fmd->ctrl0);
> + if (is_inbound)
> + ctrl0 &= ~SPU2_CIPH_ENCRYPT_EN; /* decrypt */
> + else
> + ctrl0 |= SPU2_CIPH_ENCRYPT_EN; /* encrypt */
> + fmd->ctrl0 = cpu_to_le64(ctrl0);
> +
> + if (cipher_parms->alg && cipher_parms->iv_buf && cipher_parms->iv_len) {
> + /* cipher iv provided so put it in here */
> + memcpy(omd + cipher_parms->key_len, cipher_parms->iv_buf,
> + cipher_parms->iv_len);
> + }
> +
> + ctrl3 = le64_to_cpu(fmd->ctrl3);
> + data_size &= SPU2_PL_LEN;
> + ctrl3 |= data_size;
> + fmd->ctrl3 = cpu_to_le64(ctrl3);
> +
> + packet_dump(" SPU request header: ", spu_hdr, spu_req_hdr_len);
> +}
> +
> +/**
> + * spu_request_pad() - Create pad bytes at the end of the data.
> + * @pad_start: Start of buffer where pad bytes are to be written
> + * @gcm_padding: Length of GCM padding, in bytes
> + * @hash_pad_len: Number of bytes of padding extend data to full block
> + * @auth_alg: Authentication algorithm
> + * @auth_mode: Authentication mode
> + * @total_sent: Length inserted at end of hash pad
> + * @status_padding: Number of bytes of padding to align STATUS word
> + *
> + * There may be three forms of pad:
> + * 1. GCM pad - for GCM mode ciphers, pad to 16-byte alignment
> + * 2. hash pad - pad to a block length, with 0x80 data terminator and
> + * size at the end
> + * 3. STAT pad - to ensure the STAT field is 4-byte aligned
> + */
> +void spu2_request_pad(u8 *pad_start, u32 gcm_padding, u32 hash_pad_len,
> + enum hash_alg auth_alg, enum hash_mode auth_mode,
> + unsigned int total_sent, u32 status_padding)
> +{
> + u8 *ptr = pad_start;
> +
> + /* fix data alignent for GCM */
> + if (gcm_padding > 0) {
> + flow_log(" GCM: padding to 16 byte alignment: %u bytes\n",
> + gcm_padding);
> + memset(ptr, 0, gcm_padding);
> + ptr += gcm_padding;
> + }
> +
> + if (hash_pad_len > 0) {
> + /* clear the padding section */
> + memset(ptr, 0, hash_pad_len);
> +
> + /* terminate the data */
> + *ptr = 0x80;
> + ptr += (hash_pad_len - sizeof(u64));
> +
> + /* add the size at the end as required per alg */
> + if (auth_alg == HASH_ALG_MD5)
> + *(u64 *)ptr = cpu_to_le64((u64)total_sent * 8);
> + else /* SHA1, SHA2-224, SHA2-256 */
> + *(u64 *)ptr = cpu_to_be64((u64)total_sent * 8);
> + ptr += sizeof(u64);
> + }
> +
> + /* pad to a 4byte alignment for STAT */
> + if (status_padding > 0) {
> + flow_log(" STAT: padding to 4 byte alignment: %u bytes\n",
> + status_padding);
> +
> + memset(ptr, 0, status_padding);
> + ptr += status_padding;
> + }
> +}
> +
> +/**
> + * spu2_xts_tweak_in_payload() - Indicate that SPU2 does NOT place the XTS
> + * tweak field in the packet payload (it uses IV instead)
> + *
> + * Return: 0
> + */
> +u8 spu2_xts_tweak_in_payload(void)
> +{
> + return 0;
> +}
> +
> +/**
> + * spu2_tx_status_len() - Return the length of the STATUS field in a SPU
> + * response message.
> + *
> + * Return: Length of STATUS field in bytes.
> + */
> +u8 spu2_tx_status_len(void)
> +{
> + return SPU2_TX_STATUS_LEN;
> +}
> +
> +/**
> + * spu2_rx_status_len() - Return the length of the STATUS field in a SPU
> + * response message.
> + *
> + * Return: Length of STATUS field in bytes.
> + */
> +u8 spu2_rx_status_len(void)
> +{
> + return SPU2_RX_STATUS_LEN;
> +}
> +
> +/**
> + * spu_status_process() - Process the status from a SPU response message.
> + * @statp: start of STATUS word
> + *
> + * Return: 0 - if status is good and response should be processed
> + * !0 - status indicates an error and response is invalid
> + */
> +int spu2_status_process(u8 *statp)
> +{
> + /* SPU2 status is 2 bytes by default - SPU_RX_STATUS_LEN */
> + u16 status = le16_to_cpu(*(__le16 *)statp);
> +
> + if (status == 0)
> + return 0;
> +
> + flow_log("rx status is %#x\n", status);
> + if (status == SPU2_INVALID_ICV)
> + return SPU_INVALID_ICV;
> +
> + return -EBADMSG;
> +}
> +
> +/**
> + * spu2_ccm_update_iv() - Update the IV as per the requirements for CCM mode.
> + *
> + * @digestsize: Digest size of this request
> + * @cipher_parms: (pointer to) cipher parmaeters, includes IV buf & IV len
> + * @assoclen: Length of AAD data
> + * @chunksize: length of input data to be sent in this req
> + * @is_encrypt: true if this is an output/encrypt operation
> + * @is_esp: true if this is an ESP / RFC4309 operation
> + *
> + */
> +void spu2_ccm_update_iv(unsigned int digestsize,
> + struct spu_cipher_parms *cipher_parms,
> + unsigned int assoclen, unsigned int chunksize,
> + bool is_encrypt, bool is_esp)
> +{
> + int L; /* size of length field, in bytes */
> +
> + /*
> + * In RFC4309 mode, L is fixed at 4 bytes; otherwise, IV from
> + * testmgr contains (L-1) in bottom 3 bits of first byte,
> + * per RFC 3610.
> + */
> + if (is_esp)
> + L = CCM_ESP_L_VALUE;
> + else
> + L = ((cipher_parms->iv_buf[0] & CCM_B0_L_PRIME) >>
> + CCM_B0_L_PRIME_SHIFT) + 1;
> +
> + /* SPU2 doesn't want these length bytes nor the first byte... */
> + cipher_parms->iv_len -= (1 + L);
> + memmove(cipher_parms->iv_buf, &cipher_parms->iv_buf[1],
> + cipher_parms->iv_len);
> +}
> +
> +/**
> + * spu2_wordalign_padlen() - SPU2 does not require padding.
> + * @data_size: length of data field in bytes
> + *
> + * Return: length of status field padding, in bytes (always 0 on SPU2)
> + */
> +u32 spu2_wordalign_padlen(u32 data_size)
> +{
> + return 0;
> +}
> diff --git a/drivers/crypto/bcm/spu2.h b/drivers/crypto/bcm/spu2.h
> new file mode 100644
> index 0000000..ab1f599
> --- /dev/null
> +++ b/drivers/crypto/bcm/spu2.h
> @@ -0,0 +1,228 @@
> +/*
> + * Copyright 2016 Broadcom
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License, version 2, as
> + * published by the Free Software Foundation (the "GPL").
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * General Public License version 2 (GPLv2) for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * version 2 (GPLv2) along with this source code.
> + */
> +
> +/*
> + * This file contains SPU message definitions specific to SPU2.
> + */
> +
> +#ifndef _SPU2_H
> +#define _SPU2_H
> +
> +enum spu2_cipher_type {
> + SPU2_CIPHER_TYPE_NONE = 0x0,
> + SPU2_CIPHER_TYPE_AES128 = 0x1,
> + SPU2_CIPHER_TYPE_AES192 = 0x2,
> + SPU2_CIPHER_TYPE_AES256 = 0x3,
> + SPU2_CIPHER_TYPE_DES = 0x4,
> + SPU2_CIPHER_TYPE_3DES = 0x5,
> + SPU2_CIPHER_TYPE_LAST
> +};
> +
> +enum spu2_cipher_mode {
> + SPU2_CIPHER_MODE_ECB = 0x0,
> + SPU2_CIPHER_MODE_CBC = 0x1,
> + SPU2_CIPHER_MODE_CTR = 0x2,
> + SPU2_CIPHER_MODE_CFB = 0x3,
> + SPU2_CIPHER_MODE_OFB = 0x4,
> + SPU2_CIPHER_MODE_XTS = 0x5,
> + SPU2_CIPHER_MODE_CCM = 0x6,
> + SPU2_CIPHER_MODE_GCM = 0x7,
> + SPU2_CIPHER_MODE_LAST
> +};
> +
> +enum spu2_hash_type {
> + SPU2_HASH_TYPE_NONE = 0x0,
> + SPU2_HASH_TYPE_AES128 = 0x1,
> + SPU2_HASH_TYPE_AES192 = 0x2,
> + SPU2_HASH_TYPE_AES256 = 0x3,
> + SPU2_HASH_TYPE_MD5 = 0x6,
> + SPU2_HASH_TYPE_SHA1 = 0x7,
> + SPU2_HASH_TYPE_SHA224 = 0x8,
> + SPU2_HASH_TYPE_SHA256 = 0x9,
> + SPU2_HASH_TYPE_SHA384 = 0xa,
> + SPU2_HASH_TYPE_SHA512 = 0xb,
> + SPU2_HASH_TYPE_SHA512_224 = 0xc,
> + SPU2_HASH_TYPE_SHA512_256 = 0xd,
> + SPU2_HASH_TYPE_SHA3_224 = 0xe,
> + SPU2_HASH_TYPE_SHA3_256 = 0xf,
> + SPU2_HASH_TYPE_SHA3_384 = 0x10,
> + SPU2_HASH_TYPE_SHA3_512 = 0x11,
> + SPU2_HASH_TYPE_LAST
> +};
> +
> +enum spu2_hash_mode {
> + SPU2_HASH_MODE_CMAC = 0x0,
> + SPU2_HASH_MODE_CBC_MAC = 0x1,
> + SPU2_HASH_MODE_XCBC_MAC = 0x2,
> + SPU2_HASH_MODE_HMAC = 0x3,
> + SPU2_HASH_MODE_RABIN = 0x4,
> + SPU2_HASH_MODE_CCM = 0x5,
> + SPU2_HASH_MODE_GCM = 0x6,
> + SPU2_HASH_MODE_RESERVED = 0x7,
> + SPU2_HASH_MODE_LAST
> +};
> +
> +enum spu2_ret_md_opts {
> + SPU2_RET_NO_MD = 0, /* return no metadata */
> + SPU2_RET_FMD_OMD = 1, /* return both FMD and OMD */
> + SPU2_RET_FMD_ONLY = 2, /* return only FMD */
> + SPU2_RET_FMD_OMD_IV = 3, /* return FMD and OMD with just IVs */
> +};
> +
> +/* Fixed Metadata format */
> +struct SPU2_FMD {
> + u64 ctrl0;
> + u64 ctrl1;
> + u64 ctrl2;
> + u64 ctrl3;
> +};
> +
> +#define FMD_SIZE sizeof(struct SPU2_FMD)
> +
> +/* Fixed part of request message header length in bytes. Just FMD. */
> +#define SPU2_REQ_FIXED_LEN FMD_SIZE
> +#define SPU2_HEADER_ALLOC_LEN (SPU_REQ_FIXED_LEN + \
> + 2 * MAX_KEY_SIZE + 2 * MAX_IV_SIZE)
> +
> +/* FMD ctrl0 field masks */
> +#define SPU2_CIPH_ENCRYPT_EN 0x1 /* 0: decrypt, 1: encrypt */
> +#define SPU2_CIPH_TYPE 0xF0 /* one of spu2_cipher_type */
> +#define SPU2_CIPH_TYPE_SHIFT 4
> +#define SPU2_CIPH_MODE 0xF00 /* one of spu2_cipher_mode */
> +#define SPU2_CIPH_MODE_SHIFT 8
> +#define SPU2_CFB_MASK 0x7000 /* cipher feedback mask */
> +#define SPU2_CFB_MASK_SHIFT 12
> +#define SPU2_PROTO_SEL 0xF00000 /* MACsec, IPsec, TLS... */
> +#define SPU2_PROTO_SEL_SHIFT 20
> +#define SPU2_HASH_FIRST 0x1000000 /* 1: hash input is input pkt
> + * data
> + */
> +#define SPU2_CHK_TAG 0x2000000 /* 1: check digest provided */
> +#define SPU2_HASH_TYPE 0x1F0000000 /* one of spu2_hash_type */
> +#define SPU2_HASH_TYPE_SHIFT 28
> +#define SPU2_HASH_MODE 0xF000000000 /* one of spu2_hash_mode */
> +#define SPU2_HASH_MODE_SHIFT 36
> +#define SPU2_CIPH_PAD_EN 0x100000000000 /* 1: Add pad to end of payload for
> + * enc
> + */
> +#define SPU2_CIPH_PAD 0xFF000000000000 /* cipher pad value */
> +#define SPU2_CIPH_PAD_SHIFT 48
> +
> +/* FMD ctrl1 field masks */
> +#define SPU2_TAG_LOC 0x1 /* 1: end of payload, 0: undef */
> +#define SPU2_HAS_FR_DATA 0x2 /* 1: msg has frame data */
> +#define SPU2_HAS_AAD1 0x4 /* 1: msg has AAD1 field */
> +#define SPU2_HAS_NAAD 0x8 /* 1: msg has NAAD field */
> +#define SPU2_HAS_AAD2 0x10 /* 1: msg has AAD2 field */
> +#define SPU2_HAS_ESN 0x20 /* 1: msg has ESN field */
> +#define SPU2_HASH_KEY_LEN 0xFF00 /* len of hash key in bytes.
> + * HMAC only.
> + */
> +#define SPU2_HASH_KEY_LEN_SHIFT 8
> +#define SPU2_CIPH_KEY_LEN 0xFF00000 /* len of cipher key in bytes */
> +#define SPU2_CIPH_KEY_LEN_SHIFT 20
> +#define SPU2_GENIV 0x10000000 /* 1: hw generates IV */
> +#define SPU2_HASH_IV 0x20000000 /* 1: IV incl in hash */
> +#define SPU2_RET_IV 0x40000000 /* 1: return IV in output msg
> + * b4 payload
> + */
> +#define SPU2_RET_IV_LEN 0xF00000000 /* length in bytes of IV returned.
> + * 0 = 16 bytes
> + */
> +#define SPU2_RET_IV_LEN_SHIFT 32
> +#define SPU2_IV_OFFSET 0xF000000000 /* gen IV offset */
> +#define SPU2_IV_OFFSET_SHIFT 36
> +#define SPU2_IV_LEN 0x1F0000000000 /* length of input IV in bytes */
> +#define SPU2_IV_LEN_SHIFT 40
> +#define SPU2_HASH_TAG_LEN 0x7F000000000000 /* hash tag length in bytes */
> +#define SPU2_HASH_TAG_LEN_SHIFT 48
> +#define SPU2_RETURN_MD 0x300000000000000 /* return metadata */
> +#define SPU2_RETURN_MD_SHIFT 56
> +#define SPU2_RETURN_FD 0x400000000000000
> +#define SPU2_RETURN_AAD1 0x800000000000000
> +#define SPU2_RETURN_NAAD 0x1000000000000000
> +#define SPU2_RETURN_AAD2 0x2000000000000000
> +#define SPU2_RETURN_PAY 0x4000000000000000 /* return payload */
> +
> +/* FMD ctrl2 field masks */
> +#define SPU2_AAD1_OFFSET 0xFFF /* byte offset of AAD1 field */
> +#define SPU2_AAD1_LEN 0xFF000 /* length of AAD1 in bytes */
> +#define SPU2_AAD1_LEN_SHIFT 12
> +#define SPU2_AAD2_OFFSET 0xFFF00000 /* byte offset of AAD2 field */
> +#define SPU2_AAD2_OFFSET_SHIFT 20
> +#define SPU2_PL_OFFSET 0xFFFFFFFF00000000 /* payload offset from AAD2 */
> +#define SPU2_PL_OFFSET_SHIFT 32
> +
> +/* FMD ctrl3 field masks */
> +#define SPU2_PL_LEN 0xFFFFFFFF /* payload length in bytes */
> +#define SPU2_TLS_LEN 0xFFFF00000000 /* TLS encrypt: cipher len
> + * TLS decrypt: compressed len
> + */
> +#define SPU2_TLS_LEN_SHIFT 32
> +
> +/*
> + * Max value that can be represented in the Payload Length field of the
> + * ctrl3 word of FMD.
> + */
> +#define SPU2_MAX_PAYLOAD SPU2_PL_LEN
> +
> +/* Error values returned in STATUS field of response messages */
> +#define SPU2_INVALID_ICV 1
> +
> +void spu2_dump_msg_hdr(u8 *buf, unsigned int buf_len);
> +u32 spu2_ctx_max_payload(enum spu_cipher_alg cipher_alg,
> + enum spu_cipher_mode cipher_mode,
> + unsigned int blocksize);
> +u32 spu2_payload_length(u8 *spu_hdr);
> +u16 spu2_response_hdr_len(u16 auth_key_len, u16 enc_key_len, bool is_hash);
> +u16 spu2_hash_pad_len(enum hash_alg hash_alg, enum hash_mode hash_mode,
> + u32 chunksize, u16 hash_block_size);
> +u32 spu2_gcm_ccm_pad_len(enum spu_cipher_mode cipher_mode,
> + unsigned int data_size);
> +u32 spu2_assoc_resp_len(enum spu_cipher_mode cipher_mode,
> + unsigned int assoc_len, unsigned int iv_len,
> + bool is_encrypt);
> +u8 spu2_aead_ivlen(enum spu_cipher_mode cipher_mode,
> + u16 iv_len);
> +enum hash_type spu2_hash_type(u32 src_sent);
> +u32 spu2_digest_size(u32 alg_digest_size, enum hash_alg alg,
> + enum hash_type htype);
> +u32 spu2_create_request(u8 *spu_hdr,
> + struct spu_request_opts *req_opts,
> + struct spu_cipher_parms *cipher_parms,
> + struct spu_hash_parms *hash_parms,
> + struct spu_aead_parms *aead_parms,
> + unsigned int data_size);
> +u16 spu2_cipher_req_init(u8 *spu_hdr, struct spu_cipher_parms *cipher_parms);
> +void spu2_cipher_req_finish(u8 *spu_hdr,
> + u16 spu_req_hdr_len,
> + unsigned int is_inbound,
> + struct spu_cipher_parms *cipher_parms,
> + bool update_key,
> + unsigned int data_size);
> +void spu2_request_pad(u8 *pad_start, u32 gcm_padding, u32 hash_pad_len,
> + enum hash_alg auth_alg, enum hash_mode auth_mode,
> + unsigned int total_sent, u32 status_padding);
> +u8 spu2_xts_tweak_in_payload(void);
> +u8 spu2_tx_status_len(void);
> +u8 spu2_rx_status_len(void);
> +int spu2_status_process(u8 *statp);
> +void spu2_ccm_update_iv(unsigned int digestsize,
> + struct spu_cipher_parms *cipher_parms,
> + unsigned int assoclen, unsigned int chunksize,
> + bool is_encrypt, bool is_esp);
> +u32 spu2_wordalign_padlen(u32 data_size);
> +#endif
> diff --git a/drivers/crypto/bcm/spum.h b/drivers/crypto/bcm/spum.h
> new file mode 100644
> index 0000000..d0a5b58
> --- /dev/null
> +++ b/drivers/crypto/bcm/spum.h
> @@ -0,0 +1,174 @@
> +/*
> + * Copyright 2016 Broadcom
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License, version 2, as
> + * published by the Free Software Foundation (the "GPL").
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * General Public License version 2 (GPLv2) for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * version 2 (GPLv2) along with this source code.
> + */
> +
> +/*
> + * This file contains SPU message definitions specific to SPU-M.
> + */
> +
> +#ifndef _SPUM_H_
> +#define _SPUM_H_
> +
> +#define SPU_CRYPTO_OPERATION_GENERIC 0x1
> +
> +/* Length of STATUS field in tx and rx packets */
> +#define SPU_TX_STATUS_LEN 4
> +
> +/* SPU-M error codes */
> +#define SPU_STATUS_MASK 0x0000FF00
> +#define SPU_STATUS_SUCCESS 0x00000000
> +#define SPU_STATUS_INVALID_ICV 0x00000100
> +
> +#define SPU_STATUS_ERROR_FLAG 0x00020000
> +
> +/* Request message. MH + EMH + BDESC + BD header */
> +#define SPU_REQ_FIXED_LEN 24
> +
> +/*
> + * Max length of a SPU message header. Used to allocate a buffer where
> + * the SPU message header is constructed. Can be used for either a SPU-M
> + * header or a SPU2 header.
> + * For SPU-M, sum of the following:
> + * MH - 4 bytes
> + * EMH - 4
> + * SCTX - 3 +
> + * max auth key len - 64
> + * max cipher key len - 264 (RC4)
> + * max IV len - 16
> + * BDESC - 12
> + * BD header - 4
> + * Total: 371
> + *
> + * For SPU2, FMD_SIZE (32) plus lengths of hash and cipher keys,
> + * hash and cipher IVs. If SPU2 does not support RC4, then
> + */
> +#define SPU_HEADER_ALLOC_LEN (SPU_REQ_FIXED_LEN + MAX_KEY_SIZE + \
> + MAX_KEY_SIZE + MAX_IV_SIZE)
> +
> +/*
> + * Response message header length. Normally MH, EMH, BD header, but when
> + * BD_SUPPRESS is used for hash requests, there is no BD header.
> + */
> +#define SPU_RESP_HDR_LEN 12
> +#define SPU_HASH_RESP_HDR_LEN 8
> +
> +/*
> + * Max value that can be represented in the Payload Length field of the BD
> + * header. This is a 16-bit field.
> + */
> +#define SPUM_NS2_MAX_PAYLOAD (BIT(16) - 1)
> +
> +/*
> + * NSP SPU is limited to ~9KB because of FA2 FIFO size limitations;
> + * Set MAX_PAYLOAD to 8k to allow for addition of header, digest, etc.
> + * and stay within limitation.
> + */
> +
> +#define SPUM_NSP_MAX_PAYLOAD 8192
> +
> +/* Buffer Descriptor Header [BDESC]. SPU in big-endian mode. */
> +struct BDESC_HEADER {
> + u16 offset_mac; /* word 0 [31-16] */
> + u16 length_mac; /* word 0 [15-0] */
> + u16 offset_crypto; /* word 1 [31-16] */
> + u16 length_crypto; /* word 1 [15-0] */
> + u16 offset_icv; /* word 2 [31-16] */
> + u16 offset_iv; /* word 2 [15-0] */
> +};
> +
> +/* Buffer Data Header [BD]. SPU in big-endian mode. */
> +struct BD_HEADER {
> + u16 size;
> + u16 prev_length;
> +};
> +
> +/* Command Context Header. SPU-M in big endian mode. */
> +struct MHEADER {
> + u8 flags; /* [31:24] */
> + u8 op_code; /* [23:16] */
> + u16 reserved; /* [15:0] */
> +};
> +
> +/* MH header flags bits */
> +#define MH_SUPDT_PRES BIT(0)
> +#define MH_HASH_PRES BIT(2)
> +#define MH_BD_PRES BIT(3)
> +#define MH_MFM_PRES BIT(4)
> +#define MH_BDESC_PRES BIT(5)
> +#define MH_SCTX_PRES BIT(7)
> +
> +/* SCTX word 0 bit offsets and fields masks */
> +#define SCTX_SIZE 0x000000FF
> +
> +/* SCTX word 1 bit shifts and field masks */
> +#define UPDT_OFST 0x000000FF /* offset of SCTX updateable fld */
> +#define HASH_TYPE 0x00000300 /* hash alg operation type */
> +#define HASH_TYPE_SHIFT 8
> +#define HASH_MODE 0x00001C00 /* one of spu2_hash_mode */
> +#define HASH_MODE_SHIFT 10
> +#define HASH_ALG 0x0000E000 /* hash algorithm */
> +#define HASH_ALG_SHIFT 13
> +#define CIPHER_TYPE 0x00030000 /* encryption operation type */
> +#define CIPHER_TYPE_SHIFT 16
> +#define CIPHER_MODE 0x001C0000 /* encryption mode */
> +#define CIPHER_MODE_SHIFT 18
> +#define CIPHER_ALG 0x00E00000 /* encryption algo */
> +#define CIPHER_ALG_SHIFT 21
> +#define ICV_IS_512 BIT(27)
> +#define ICV_IS_512_SHIFT 27
> +#define CIPHER_ORDER BIT(30)
> +#define CIPHER_ORDER_SHIFT 30
> +#define CIPHER_INBOUND BIT(31)
> +#define CIPHER_INBOUND_SHIFT 31
> +
> +/* SCTX word 2 bit shifts and field masks */
> +#define EXP_IV_SIZE 0x7
> +#define IV_OFFSET BIT(3)
> +#define IV_OFFSET_SHIFT 3
> +#define GEN_IV BIT(5)
> +#define GEN_IV_SHIFT 5
> +#define EXPLICIT_IV BIT(6)
> +#define EXPLICIT_IV_SHIFT 6
> +#define SCTX_IV BIT(7)
> +#define SCTX_IV_SHIFT 7
> +#define ICV_SIZE 0x0F00
> +#define ICV_SIZE_SHIFT 8
> +#define CHECK_ICV BIT(12)
> +#define CHECK_ICV_SHIFT 12
> +#define INSERT_ICV BIT(13)
> +#define INSERT_ICV_SHIFT 13
> +#define BD_SUPPRESS BIT(19)
> +#define BD_SUPPRESS_SHIFT 19
> +
> +/* Generic Mode Security Context Structure [SCTX] */
> +struct SCTX {
> +/* word 0: protocol flags */
> + u32 proto_flags;
> +
> +/* word 1: cipher flags */
> + u32 cipher_flags;
> +
> +/* word 2: Extended cipher flags */
> + u32 ecf;
> +
> +};
> +
> +struct SPUHEADER {
> + struct MHEADER mh;
> + u32 emh;
> + struct SCTX sa;
> +};
> +
> +#endif /* _SPUM_H_ */
> diff --git a/drivers/crypto/bcm/util.c b/drivers/crypto/bcm/util.c
> new file mode 100644
> index 0000000..dca540f
> --- /dev/null
> +++ b/drivers/crypto/bcm/util.c
> @@ -0,0 +1,584 @@
> +/*
> + * Copyright 2016 Broadcom
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License, version 2, as
> + * published by the Free Software Foundation (the "GPL").
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * General Public License version 2 (GPLv2) for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * version 2 (GPLv2) along with this source code.
> + */
> +
> +#include <linux/debugfs.h>
> +
> +#include "cipher.h"
> +#include "util.h"
> +
> +/* offset of SPU_OFIFO_CTRL register */
> +#define SPU_OFIFO_CTRL 0x40
> +#define SPU_FIFO_WATERMARK 0x1FF
> +
> +/**
> + * spu_sg_at_offset() - Find the scatterlist entry at a given distance from the
> + * start of a scatterlist.
> + * @sg: [in] Start of a scatterlist
> + * @skip: [in] Distance from the start of the scatterlist, in bytes
> + * @sge: [out] Scatterlist entry at skip bytes from start
> + * @sge_offset: [out] Number of bytes from start of sge buffer to get to
> + * requested distance.
> + *
> + * Return: 0 if entry found at requested distance
> + * < 0 otherwise
> + */
> +int spu_sg_at_offset(struct scatterlist *sg, unsigned int skip,
> + struct scatterlist **sge, unsigned int *sge_offset)
> +{
> + /* byte index from start of sg to the end of the previous entry */
> + unsigned int index = 0;
> + /* byte index from start of sg to the end of the current entry */
> + unsigned int next_index;
> +
> + next_index = sg->length;
> + while (next_index <= skip) {
> + sg = sg_next(sg);
> + index = next_index;
> + if (!sg)
> + return -EINVAL;
> + next_index += sg->length;
> + }
> +
> + *sge_offset = skip - index;
> + *sge = sg;
> + return 0;
> +}
> +
> +/* Copy len bytes of sg data, starting at offset skip, to a dest buffer */
> +void sg_copy_part_to_buf(struct scatterlist *src, u8 *dest,
> + unsigned int len, unsigned int skip)
> +{
> + size_t copied;
> + unsigned int nents = sg_nents(src);
> +
> + copied = sg_pcopy_to_buffer(src, nents, dest, len, skip);
> + if (copied != len) {
> + flow_log("%s copied %u bytes of %u requested. ",
> + __func__, (u32)copied, len);
> + flow_log("sg with %u entries and skip %u\n", nents, skip);
> + }
> +}
> +
> +/*
> + * Copy data into a scatterlist starting at a specified offset in the
> + * scatterlist. Specifically, copy len bytes of data in the buffer src
> + * into the scatterlist dest, starting skip bytes into the scatterlist.
> + */
> +void sg_copy_part_from_buf(struct scatterlist *dest, u8 *src,
> + unsigned int len, unsigned int skip)
> +{
> + size_t copied;
> + unsigned int nents = sg_nents(dest);
> +
> + copied = sg_pcopy_from_buffer(dest, nents, src, len, skip);
> + if (copied != len) {
> + flow_log("%s copied %u bytes of %u requested. ",
> + __func__, (u32)copied, len);
> + flow_log("sg with %u entries and skip %u\n", nents, skip);
> + }
> +}
> +
> +/**
> + * spu_sg_count() - Determine number of elements in scatterlist to provide a
> + * specified number of bytes.
> + * @sg_list: scatterlist to examine
> + * @skip: index of starting point
> + * @nbytes: consider elements of scatterlist until reaching this number of
> + * bytes
> + *
> + * Return: the number of sg entries contributing to nbytes of data
> + */
> +int spu_sg_count(struct scatterlist *sg_list, unsigned int skip, int nbytes)
> +{
> + struct scatterlist *sg;
> + int sg_nents = 0;
> + unsigned int offset;
> +
> + if (!sg_list)
> + return 0;
> +
> + if (spu_sg_at_offset(sg_list, skip, &sg, &offset) < 0)
> + return 0;
> +
> + while (sg && (nbytes > 0)) {
> + sg_nents++;
> + nbytes -= (sg->length - offset);
> + offset = 0;
> + sg = sg_next(sg);
> + }
> + return sg_nents;
> +}
> +
> +/**
> + * spu_msg_sg_add() - Copy scatterlist entries from one sg to another, up to a
> + * given length.
> + * @to_sg: scatterlist to copy to
> + * @from_sg: scatterlist to copy from
> + * @from_skip: number of bytes to skip in from_sg. Non-zero when previous
> + * request included part of the buffer in entry in from_sg.
> + * Assumes from_skip < from_sg->length.
> + * @from_nents number of entries in from_sg
> + * @length number of bytes to copy. may reach this limit before exhausting
> + * from_sg.
> + *
> + * Copies the entries themselves, not the data in the entries. Assumes to_sg has
> + * enough entries. Does not limit the size of an individual buffer in to_sg.
> + *
> + * to_sg, from_sg, skip are all updated to end of copy
> + *
> + * Return: Number of bytes copied
> + */
> +u32 spu_msg_sg_add(struct scatterlist **to_sg,
> + struct scatterlist **from_sg, u32 *from_skip,
> + u8 from_nents, u32 length)
> +{
> + struct scatterlist *sg; /* an entry in from_sg */
> + struct scatterlist *to = *to_sg;
> + struct scatterlist *from = *from_sg;
> + u32 skip = *from_skip;
> + u32 offset;
> + int i;
> + u32 entry_len = 0;
> + u32 frag_len = 0; /* length of entry added to to_sg */
> + u32 copied = 0; /* number of bytes copied so far */
> +
> + if (length == 0)
> + return 0;
> +
> + for_each_sg(from, sg, from_nents, i) {
> + /* number of bytes in this from entry not yet used */
> + entry_len = sg->length - skip;
> + frag_len = min(entry_len, length - copied);
> + offset = sg->offset + skip;
> + if (frag_len)
> + sg_set_page(to++, sg_page(sg), frag_len, offset);
> + copied += frag_len;
> + if (copied == entry_len) {
> + /* used up all of from entry */
> + skip = 0; /* start at beginning of next entry */
> + }
> + if (copied == length)
> + break;
> + }
> + *to_sg = to;
> + *from_sg = sg;
> + if (frag_len < entry_len)
> + *from_skip = skip + frag_len;
> + else
> + *from_skip = 0;
> +
> + return copied;
> +}
> +
> +void add_to_ctr(u8 *ctr_pos, unsigned int increment)
> +{
> + __be64 *high_be = (__be64 *)ctr_pos;
> + __be64 *low_be = high_be + 1;
> + u64 orig_low = __be64_to_cpu(*low_be);
> + u64 new_low = orig_low + (u64)increment;
> +
> + *low_be = __cpu_to_be64(new_low);
> + if (new_low < orig_low)
> + /* there was a carry from the low 8 bytes */
> + *high_be = __cpu_to_be64(__be64_to_cpu(*high_be) + 1);
> +}
> +
> +struct sdesc {
> + struct shash_desc shash;
> + char ctx[];
> +};
> +
> +/* do a synchronous decrypt operation */
> +int do_decrypt(char *alg_name,
> + void *key_ptr, unsigned int key_len,
> + void *iv_ptr, void *src_ptr, void *dst_ptr,
> + unsigned int block_len)
> +{
> + struct scatterlist sg_in[1], sg_out[1];
> + struct crypto_blkcipher *tfm =
> + crypto_alloc_blkcipher(alg_name, 0, CRYPTO_ALG_ASYNC);
> + struct blkcipher_desc desc = {.tfm = tfm, .flags = 0 };
> + int ret = 0;
> + void *iv;
> + int ivsize;
> +
> + flow_log("%s() name:%s block_len:%u\n", __func__, alg_name, block_len);
> +
> + if (IS_ERR(tfm))
> + return PTR_ERR(tfm);
> +
> + crypto_blkcipher_setkey((void *)tfm, key_ptr, key_len);
> +
> + sg_init_table(sg_in, 1);
> + sg_set_buf(sg_in, src_ptr, block_len);
> +
> + sg_init_table(sg_out, 1);
> + sg_set_buf(sg_out, dst_ptr, block_len);
> +
> + iv = crypto_blkcipher_crt(tfm)->iv;
> + ivsize = crypto_blkcipher_ivsize(tfm);
> + memcpy(iv, iv_ptr, ivsize);
> +
> + ret = crypto_blkcipher_decrypt(&desc, sg_out, sg_in, block_len);
> + crypto_free_blkcipher(tfm);
> +
> + if (ret < 0)
> + pr_err("aes_decrypt failed %d\n", ret);
> +
> + return ret;
> +}
> +
> +/**
> + * do_shash() - Do a synchronous hash operation in software
> + * @name: The name of the hash algorithm
> + * @result: Buffer where digest is to be written
> + * @data1: First part of data to hash. May be NULL.
> + * @data1_len: Length of data1, in bytes
> + * @data2: Second part of data to hash. May be NULL.
> + * @data2_len: Length of data2, in bytes
> + * @key: Key (if keyed hash)
> + * @key_len: Length of key, in bytes (or 0 if non-keyed hash)
> + *
> + * Note that the crypto API will not select this driver's own transform because
> + * this driver only registers asynchronous algos.
> + *
> + * Return: 0 if hash successfully stored in result
> + * < 0 otherwise
> + */
> +int do_shash(unsigned char *name, unsigned char *result,
> + const u8 *data1, unsigned int data1_len,
> + const u8 *data2, unsigned int data2_len,
> + const u8 *key, unsigned int key_len)
> +{
> + int rc;
> + unsigned int size;
> + struct crypto_shash *hash;
> + struct sdesc *sdesc;
> +
> + hash = crypto_alloc_shash(name, 0, 0);
> + if (IS_ERR(hash)) {
> + rc = PTR_ERR(hash);
> + pr_err("%s: Crypto %s allocation error %d", __func__, name, rc);
> + return rc;
> + }
> +
> + size = sizeof(struct shash_desc) + crypto_shash_descsize(hash);
> + sdesc = kmalloc(size, GFP_KERNEL);
> + if (!sdesc) {
> + rc = -ENOMEM;
> + pr_err("%s: Memory allocation failure", __func__);
> + goto do_shash_err;
> + }
> + sdesc->shash.tfm = hash;
> + sdesc->shash.flags = 0x0;
> +
> + if (key_len > 0) {
> + rc = crypto_shash_setkey(hash, key, key_len);
> + if (rc) {
> + pr_err("%s: Could not setkey %s shash", __func__, name);
> + goto do_shash_err;
> + }
> + }
> +
> + rc = crypto_shash_init(&sdesc->shash);
> + if (rc) {
> + pr_err("%s: Could not init %s shash", __func__, name);
> + goto do_shash_err;
> + }
> + rc = crypto_shash_update(&sdesc->shash, data1, data1_len);
> + if (rc) {
> + pr_err("%s: Could not update1", __func__);
> + goto do_shash_err;
> + }
> + if (data2 && data2_len) {
> + rc = crypto_shash_update(&sdesc->shash, data2, data2_len);
> + if (rc) {
> + pr_err("%s: Could not update2", __func__);
> + goto do_shash_err;
> + }
> + }
> + rc = crypto_shash_final(&sdesc->shash, result);
> + if (rc)
> + pr_err("%s: Could not genereate %s hash", __func__, name);
> +
> +do_shash_err:
> + crypto_free_shash(hash);
> + kfree(sdesc);
> +
> + return rc;
> +}
> +
> +/* Dump len bytes of a scatterlist starting at skip bytes into the sg */
> +void __dump_sg(struct scatterlist *sg, unsigned int skip, unsigned int len)
> +{
> + u8 dbuf[16];
> + unsigned int idx = skip;
> + unsigned int num_out = 0; /* number of bytes dumped so far */
> + unsigned int count;
> +
> + if (packet_debug_logging) {
> + while (num_out < len) {
> + count = (len - num_out > 16) ? 16 : len - num_out;
> + sg_copy_part_to_buf(sg, dbuf, count, idx);
> + num_out += count;
> + print_hex_dump(KERN_ALERT, " sg: ", DUMP_PREFIX_NONE,
> + 4, 1, dbuf, count, false);
> + idx += 16;
> + }
> + }
> + if (debug_logging_sleep)
> + msleep(debug_logging_sleep);
> +}
> +
> +/* Returns the name for a given cipher alg/mode */
> +char *spu_alg_name(enum spu_cipher_alg alg, enum spu_cipher_mode mode)
> +{
> + switch (alg) {
> + case CIPHER_ALG_RC4:
> + return "rc4";
> + case CIPHER_ALG_AES:
> + switch (mode) {
> + case CIPHER_MODE_CBC:
> + return "cbc(aes)";
> + case CIPHER_MODE_ECB:
> + return "ecb(aes)";
> + case CIPHER_MODE_OFB:
> + return "ofb(aes)";
> + case CIPHER_MODE_CFB:
> + return "cfb(aes)";
> + case CIPHER_MODE_CTR:
> + return "ctr(aes)";
> + case CIPHER_MODE_XTS:
> + return "xts(aes)";
> + case CIPHER_MODE_GCM:
> + return "gcm(aes)";
> + default:
> + return "aes";
> + }
> + break;
> + case CIPHER_ALG_DES:
> + switch (mode) {
> + case CIPHER_MODE_CBC:
> + return "cbc(des)";
> + case CIPHER_MODE_ECB:
> + return "ecb(des)";
> + case CIPHER_MODE_CTR:
> + return "ctr(des)";
> + default:
> + return "des";
> + }
> + break;
> + case CIPHER_ALG_3DES:
> + switch (mode) {
> + case CIPHER_MODE_CBC:
> + return "cbc(des3_ede)";
> + case CIPHER_MODE_ECB:
> + return "ecb(des3_ede)";
> + case CIPHER_MODE_CTR:
> + return "ctr(des3_ede)";
> + default:
> + return "3des";
> + }
> + break;
> + default:
> + return "other";
> + }
> +}
> +
> +static ssize_t spu_debugfs_read(struct file *filp, char __user *ubuf,
> + size_t count, loff_t *offp)
> +{
> + struct device_private *ipriv;
> + char *buf;
> + ssize_t ret, out_offset, out_count;
> + int i;
> + u32 fifo_len;
> + u32 spu_ofifo_ctrl;
> + u32 alg;
> + u32 mode;
> + u32 op_cnt;
> +
> + out_count = 2048;
> +
> + buf = kmalloc(out_count, GFP_KERNEL);
> + if (!buf)
> + return -ENOMEM;
> +
> + ipriv = filp->private_data;
> + out_offset = 0;
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "Number of SPUs.........%u\n",
> + ipriv->spu.num_spu);
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "Number of channels.....%u\n",
> + ipriv->spu.num_chan);
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "Current sessions.......%u\n",
> + atomic_read(&ipriv->session_count));
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "Session count..........%u\n",
> + atomic_read(&ipriv->stream_count));
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "Cipher setkey..........%u\n",
> + atomic_read(&ipriv->setkey_cnt[SPU_OP_CIPHER]));
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "Cipher Ops.............%u\n",
> + atomic_read(&ipriv->op_counts[SPU_OP_CIPHER]));
> + for (alg = 0; alg < CIPHER_ALG_LAST; alg++) {
> + for (mode = 0; mode < CIPHER_MODE_LAST; mode++) {
> + op_cnt = atomic_read(&ipriv->cipher_cnt[alg][mode]);
> + if (op_cnt) {
> + out_offset += snprintf(buf + out_offset,
> + out_count - out_offset,
> + " %-13s%11u\n",
> + spu_alg_name(alg, mode), op_cnt);
> + }
> + }
> + }
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "Hash Ops...............%u\n",
> + atomic_read(&ipriv->op_counts[SPU_OP_HASH]));
> + for (alg = 0; alg < HASH_ALG_LAST; alg++) {
> + op_cnt = atomic_read(&ipriv->hash_cnt[alg]);
> + if (op_cnt) {
> + out_offset += snprintf(buf + out_offset,
> + out_count - out_offset,
> + " %-13s%11u\n",
> + hash_alg_name[alg], op_cnt);
> + }
> + }
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "HMAC setkey............%u\n",
> + atomic_read(&ipriv->setkey_cnt[SPU_OP_HMAC]));
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "HMAC Ops...............%u\n",
> + atomic_read(&ipriv->op_counts[SPU_OP_HMAC]));
> + for (alg = 0; alg < HASH_ALG_LAST; alg++) {
> + op_cnt = atomic_read(&ipriv->hmac_cnt[alg]);
> + if (op_cnt) {
> + out_offset += snprintf(buf + out_offset,
> + out_count - out_offset,
> + " %-13s%11u\n",
> + hash_alg_name[alg], op_cnt);
> + }
> + }
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "AEAD setkey............%u\n",
> + atomic_read(&ipriv->setkey_cnt[SPU_OP_AEAD]));
> +
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "AEAD Ops...............%u\n",
> + atomic_read(&ipriv->op_counts[SPU_OP_AEAD]));
> + for (alg = 0; alg < AEAD_TYPE_LAST; alg++) {
> + op_cnt = atomic_read(&ipriv->aead_cnt[alg]);
> + if (op_cnt) {
> + out_offset += snprintf(buf + out_offset,
> + out_count - out_offset,
> + " %-13s%11u\n",
> + aead_alg_name[alg], op_cnt);
> + }
> + }
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "Bytes of req data......%llu\n",
> + (u64)atomic64_read(&ipriv->bytes_out));
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "Bytes of resp data.....%llu\n",
> + (u64)atomic64_read(&ipriv->bytes_in));
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "Mailbox full...........%u\n",
> + atomic_read(&ipriv->mb_no_spc));
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "Mailbox send failures..%u\n",
> + atomic_read(&ipriv->mb_send_fail));
> + out_offset += snprintf(buf + out_offset, out_count - out_offset,
> + "Check ICV errors.......%u\n",
> + atomic_read(&ipriv->bad_icv));
> + if (ipriv->spu.spu_type == SPU_TYPE_SPUM)
> + for (i = 0; i < ipriv->spu.num_spu; i++) {
> + spu_ofifo_ctrl = ioread32(ipriv->spu.reg_vbase[i] +
> + SPU_OFIFO_CTRL);
> + fifo_len = spu_ofifo_ctrl & SPU_FIFO_WATERMARK;
> + out_offset += snprintf(buf + out_offset,
> + out_count - out_offset,
> + "SPU %d output FIFO high water.....%u\n",
> + i, fifo_len);
> + }
> +
> + if (out_offset > out_count)
> + out_offset = out_count;
> +
> + ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
> + kfree(buf);
> + return ret;
> +}
> +
> +static const struct file_operations spu_debugfs_stats = {
> + .owner = THIS_MODULE,
> + .open = simple_open,
> + .read = spu_debugfs_read,
> +};
> +
> +/*
> + * Create the debug FS directories. If the top-level directory has not yet
> + * been created, create it now. Create a stats file in this directory for
> + * a SPU.
> + */
> +void spu_setup_debugfs(void)
> +{
> + if (!debugfs_initialized())
> + return;
> +
> + if (!iproc_priv.debugfs_dir)
> + iproc_priv.debugfs_dir = debugfs_create_dir(KBUILD_MODNAME,
> + NULL);
> +
> + if (!iproc_priv.debugfs_stats)
> + /* Create file with permissions S_IRUSR */
> + debugfs_create_file("stats", 0400, iproc_priv.debugfs_dir,
> + &iproc_priv, &spu_debugfs_stats);
> +}
> +
> +void spu_free_debugfs(void)
> +{
> + debugfs_remove_recursive(iproc_priv.debugfs_dir);
> + iproc_priv.debugfs_dir = NULL;
> +}
> +
> +/**
> + * format_value_ccm() - Format a value into a buffer, using a specified number
> + * of bytes (i.e. maybe writing value X into a 4 byte
> + * buffer, or maybe into a 12 byte buffer), as per the
> + * SPU CCM spec.
> + *
> + * @val: value to write (up to max of unsigned int)
> + * @buf: (pointer to) buffer to write the value
> + * @len: number of bytes to use (0 to 255)
> + *
> + */
> +void format_value_ccm(unsigned int val, u8 *buf, u8 len)
> +{
> + int i;
> +
> + /* First clear full output buffer */
> + memset(buf, 0, len);
> +
> + /* Then, starting from right side, fill in with data */
> + for (i = 0; i < len; i++) {
> + buf[len - i - 1] = (val >> (8 * i)) & 0xff;
> + if (i >= 3)
> + break; /* Only handle up to 32 bits of 'val' */
> + }
> +}
> diff --git a/drivers/crypto/bcm/util.h b/drivers/crypto/bcm/util.h
> new file mode 100644
> index 0000000..b858c45
> --- /dev/null
> +++ b/drivers/crypto/bcm/util.h
> @@ -0,0 +1,117 @@
> +/*
> + * Copyright 2016 Broadcom
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License, version 2, as
> + * published by the Free Software Foundation (the "GPL").
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * General Public License version 2 (GPLv2) for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * version 2 (GPLv2) along with this source code.
> + */
> +
> +#ifndef _UTIL_H
> +#define _UTIL_H
> +
> +#include <linux/kernel.h>
> +#include <linux/delay.h>
> +
> +#include "spu.h"
> +
> +extern int flow_debug_logging;
> +extern int packet_debug_logging;
> +extern int debug_logging_sleep;
> +
> +#ifdef DEBUG
> +#define flow_log(...) \
> + do { \
> + if (flow_debug_logging) { \
> + printk(__VA_ARGS__); \
> + if (debug_logging_sleep) \
> + msleep(debug_logging_sleep); \
> + } \
> + } while (0)
> +#define flow_dump(msg, var, var_len) \
> + do { \
> + if (flow_debug_logging) { \
> + print_hex_dump(KERN_ALERT, msg, DUMP_PREFIX_NONE, \
> + 16, 1, var, var_len, false); \
> + if (debug_logging_sleep) \
> + msleep(debug_logging_sleep); \
> + } \
> + } while (0)
> +
> +#define packet_log(...) \
> + do { \
> + if (packet_debug_logging) { \
> + printk(__VA_ARGS__); \
> + if (debug_logging_sleep) \
> + msleep(debug_logging_sleep); \
> + } \
> + } while (0)
> +#define packet_dump(msg, var, var_len) \
> + do { \
> + if (packet_debug_logging) { \
> + print_hex_dump(KERN_ALERT, msg, DUMP_PREFIX_NONE, \
> + 16, 1, var, var_len, false); \
> + if (debug_logging_sleep) \
> + msleep(debug_logging_sleep); \
> + } \
> + } while (0)
> +
> +void __dump_sg(struct scatterlist *sg, unsigned int skip, unsigned int len);
> +
> +#define dump_sg(sg, skip, len) __dump_sg(sg, skip, len)
> +
> +#else /* !DEBUG_ON */
> +
> +#define flow_log(...) do {} while (0)
> +#define flow_dump(msg, var, var_len) do {} while (0)
> +#define packet_log(...) do {} while (0)
> +#define packet_dump(msg, var, var_len) do {} while (0)
> +
> +#define dump_sg(sg, skip, len) do {} while (0)
> +
> +#endif /* DEBUG_ON */
> +
> +int spu_sg_at_offset(struct scatterlist *sg, unsigned int skip,
> + struct scatterlist **sge, unsigned int *sge_offset);
> +
> +/* Copy sg data, from skip, length len, to dest */
> +void sg_copy_part_to_buf(struct scatterlist *src, u8 *dest,
> + unsigned int len, unsigned int skip);
> +/* Copy src into scatterlist from offset, length len */
> +void sg_copy_part_from_buf(struct scatterlist *dest, u8 *src,
> + unsigned int len, unsigned int skip);
> +
> +int spu_sg_count(struct scatterlist *sg_list, unsigned int skip, int nbytes);
> +u32 spu_msg_sg_add(struct scatterlist **to_sg,
> + struct scatterlist **from_sg, u32 *skip,
> + u8 from_nents, u32 tot_len);
> +
> +void add_to_ctr(u8 *ctr_pos, unsigned int increment);
> +
> +/* do a synchronous decrypt operation */
> +int do_decrypt(char *alg_name,
> + void *key_ptr, unsigned int key_len,
> + void *iv_ptr, void *src_ptr, void *dst_ptr,
> + unsigned int block_len);
> +
> +/* produce a message digest from data of length n bytes */
> +int do_shash(unsigned char *name, unsigned char *result,
> + const u8 *data1, unsigned int data1_len,
> + const u8 *data2, unsigned int data2_len,
> + const u8 *key, unsigned int key_len);
> +
> +char *spu_alg_name(enum spu_cipher_alg alg, enum spu_cipher_mode mode);
> +
> +void spu_setup_debugfs(void);
> +void spu_free_debugfs(void);
> +void spu_free_debugfs_stats(void);
> +void format_value_ccm(unsigned int val, u8 *buf, u8 len);
> +
> +#endif
> --
> 2.1.0
>
^ permalink raw reply
* [PATCH v3] rtc: add support for EPSON TOYOCOM RTC-7301SF/DG
From: Akinobu Mita @ 2016-12-04 14:04 UTC (permalink / raw)
To: rtc-linux-/JYPxA39Uh5TLH3MbocFFw,
devicetree-u79uwXL29TY76Z2rM5mHXA
Cc: Akinobu Mita, Alessandro Zummo, Alexandre Belloni
This adds support for EPSON TOYOCOM RTC-7301SF/DG which has parallel
interface compatible with SRAM.
This driver supports basic clock, calendar and alarm functionality.
Tested with Microblaze linux running on Artix7 FPGA board with my own
custom IP for RTC-7301.
Signed-off-by: Akinobu Mita <akinobu.mita-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>
Acked-by: Rob Herring <robh-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org>
Cc: Alessandro Zummo <a.zummo-BfzFCNDTiLLj+vYz1yj4TQ@public.gmane.org>
Cc: Alexandre Belloni <alexandre.belloni-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8@public.gmane.org>
---
* Changes from v2
- Convert enum to usual #defines
.../devicetree/bindings/rtc/epson,rtc7301.txt | 16 +
drivers/rtc/Kconfig | 11 +
drivers/rtc/Makefile | 1 +
drivers/rtc/rtc-r7301.c | 453 +++++++++++++++++++++
4 files changed, 481 insertions(+)
create mode 100644 Documentation/devicetree/bindings/rtc/epson,rtc7301.txt
create mode 100644 drivers/rtc/rtc-r7301.c
diff --git a/Documentation/devicetree/bindings/rtc/epson,rtc7301.txt b/Documentation/devicetree/bindings/rtc/epson,rtc7301.txt
new file mode 100644
index 0000000..5f9df3f
--- /dev/null
+++ b/Documentation/devicetree/bindings/rtc/epson,rtc7301.txt
@@ -0,0 +1,16 @@
+EPSON TOYOCOM RTC-7301SF/DG
+
+Required properties:
+
+- compatible: Should be "epson,rtc7301sf" or "epson,rtc7301dg"
+- reg: Specifies base physical address and size of the registers.
+- interrupts: A single interrupt specifier.
+
+Example:
+
+rtc: rtc@44a00000 {
+ compatible = "epson,rtc7301dg";
+ reg = <0x44a00000 0x10000>;
+ interrupt-parent = <&axi_intc_0>;
+ interrupts = <3 2>;
+};
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 0a5e058..b8f1f9c 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -1705,6 +1705,17 @@ config RTC_DRV_PIC32
This driver can also be built as a module. If so, the module
will be called rtc-pic32
+config RTC_DRV_R7301
+ tristate "EPSON TOYOCOM RTC-7301SF/DG"
+ select REGMAP_MMIO
+ depends on OF && HAS_IOMEM
+ help
+ If you say yes here you get support for the EPSON TOYOCOM
+ RTC-7301SF/DG chips.
+
+ This driver can also be built as a module. If so, the module
+ will be called rtc-r7301.
+
comment "HID Sensor RTC drivers"
config RTC_DRV_HID_SENSOR_TIME
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 1ac694a..f13ab1c 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -120,6 +120,7 @@ obj-$(CONFIG_RTC_DRV_PM8XXX) += rtc-pm8xxx.o
obj-$(CONFIG_RTC_DRV_PS3) += rtc-ps3.o
obj-$(CONFIG_RTC_DRV_PUV3) += rtc-puv3.o
obj-$(CONFIG_RTC_DRV_PXA) += rtc-pxa.o
+obj-$(CONFIG_RTC_DRV_R7301) += rtc-r7301.o
obj-$(CONFIG_RTC_DRV_R9701) += rtc-r9701.o
obj-$(CONFIG_RTC_DRV_RC5T583) += rtc-rc5t583.o
obj-$(CONFIG_RTC_DRV_RK808) += rtc-rk808.o
diff --git a/drivers/rtc/rtc-r7301.c b/drivers/rtc/rtc-r7301.c
new file mode 100644
index 0000000..28d5408
--- /dev/null
+++ b/drivers/rtc/rtc-r7301.c
@@ -0,0 +1,453 @@
+/*
+ * EPSON TOYOCOM RTC-7301SF/DG Driver
+ *
+ * Copyright (c) 2016 Akinobu Mita <akinobu.mita-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>
+ *
+ * Based on rtc-rp5c01.c
+ *
+ * Datasheet: http://www5.epsondevice.com/en/products/parallel/rtc7301sf.html
+ */
+
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/regmap.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+
+#define DRV_NAME "rtc-r7301"
+
+#define RTC7301_1_SEC 0x0 /* Bank 0 and Band 1 */
+#define RTC7301_10_SEC 0x1 /* Bank 0 and Band 1 */
+#define RTC7301_AE BIT(3)
+#define RTC7301_1_MIN 0x2 /* Bank 0 and Band 1 */
+#define RTC7301_10_MIN 0x3 /* Bank 0 and Band 1 */
+#define RTC7301_1_HOUR 0x4 /* Bank 0 and Band 1 */
+#define RTC7301_10_HOUR 0x5 /* Bank 0 and Band 1 */
+#define RTC7301_DAY_OF_WEEK 0x6 /* Bank 0 and Band 1 */
+#define RTC7301_1_DAY 0x7 /* Bank 0 and Band 1 */
+#define RTC7301_10_DAY 0x8 /* Bank 0 and Band 1 */
+#define RTC7301_1_MONTH 0x9 /* Bank 0 */
+#define RTC7301_10_MONTH 0xa /* Bank 0 */
+#define RTC7301_1_YEAR 0xb /* Bank 0 */
+#define RTC7301_10_YEAR 0xc /* Bank 0 */
+#define RTC7301_100_YEAR 0xd /* Bank 0 */
+#define RTC7301_1000_YEAR 0xe /* Bank 0 */
+#define RTC7301_ALARM_CONTROL 0xe /* Bank 1 */
+#define RTC7301_ALARM_CONTROL_AIE BIT(0)
+#define RTC7301_ALARM_CONTROL_AF BIT(1)
+#define RTC7301_TIMER_CONTROL 0xe /* Bank 2 */
+#define RTC7301_TIMER_CONTROL_TIE BIT(0)
+#define RTC7301_TIMER_CONTROL_TF BIT(1)
+#define RTC7301_CONTROL 0xf /* All banks */
+#define RTC7301_CONTROL_BUSY BIT(0)
+#define RTC7301_CONTROL_STOP BIT(1)
+#define RTC7301_CONTROL_BANK_SEL_0 BIT(2)
+#define RTC7301_CONTROL_BANK_SEL_1 BIT(3)
+
+struct rtc7301_priv {
+ struct regmap *regmap;
+ int irq;
+ spinlock_t lock;
+ u8 bank;
+};
+
+static const struct regmap_config rtc7301_regmap_config = {
+ .reg_bits = 32,
+ .val_bits = 8,
+ .reg_stride = 4,
+};
+
+static u8 rtc7301_read(struct rtc7301_priv *priv, unsigned int reg)
+{
+ int reg_stride = regmap_get_reg_stride(priv->regmap);
+ unsigned int val;
+
+ regmap_read(priv->regmap, reg_stride * reg, &val);
+
+ return val & 0xf;
+}
+
+static void rtc7301_write(struct rtc7301_priv *priv, u8 val, unsigned int reg)
+{
+ int reg_stride = regmap_get_reg_stride(priv->regmap);
+
+ regmap_write(priv->regmap, reg_stride * reg, val);
+}
+
+static void rtc7301_update_bits(struct rtc7301_priv *priv, unsigned int reg,
+ u8 mask, u8 val)
+{
+ int reg_stride = regmap_get_reg_stride(priv->regmap);
+
+ regmap_update_bits(priv->regmap, reg_stride * reg, mask, val);
+}
+
+static int rtc7301_wait_while_busy(struct rtc7301_priv *priv)
+{
+ int retries = 100;
+
+ while (retries-- > 0) {
+ u8 val;
+
+ val = rtc7301_read(priv, RTC7301_CONTROL);
+ if (!(val & RTC7301_CONTROL_BUSY))
+ return 0;
+
+ usleep_range(200, 300);
+ }
+
+ return -ETIMEDOUT;
+}
+
+static void rtc7301_stop(struct rtc7301_priv *priv)
+{
+ rtc7301_update_bits(priv, RTC7301_CONTROL, RTC7301_CONTROL_STOP,
+ RTC7301_CONTROL_STOP);
+}
+
+static void rtc7301_start(struct rtc7301_priv *priv)
+{
+ rtc7301_update_bits(priv, RTC7301_CONTROL, RTC7301_CONTROL_STOP, 0);
+}
+
+static void rtc7301_select_bank(struct rtc7301_priv *priv, u8 bank)
+{
+ u8 val = 0;
+
+ if (bank == priv->bank)
+ return;
+
+ if (bank & BIT(0))
+ val |= RTC7301_CONTROL_BANK_SEL_0;
+ if (bank & BIT(1))
+ val |= RTC7301_CONTROL_BANK_SEL_1;
+
+ rtc7301_update_bits(priv, RTC7301_CONTROL,
+ RTC7301_CONTROL_BANK_SEL_0 |
+ RTC7301_CONTROL_BANK_SEL_1, val);
+
+ priv->bank = bank;
+}
+
+static void rtc7301_get_time(struct rtc7301_priv *priv, struct rtc_time *tm,
+ bool alarm)
+{
+ int year;
+
+ tm->tm_sec = rtc7301_read(priv, RTC7301_1_SEC);
+ tm->tm_sec += (rtc7301_read(priv, RTC7301_10_SEC) & ~RTC7301_AE) * 10;
+ tm->tm_min = rtc7301_read(priv, RTC7301_1_MIN);
+ tm->tm_min += (rtc7301_read(priv, RTC7301_10_MIN) & ~RTC7301_AE) * 10;
+ tm->tm_hour = rtc7301_read(priv, RTC7301_1_HOUR);
+ tm->tm_hour += (rtc7301_read(priv, RTC7301_10_HOUR) & ~RTC7301_AE) * 10;
+ tm->tm_mday = rtc7301_read(priv, RTC7301_1_DAY);
+ tm->tm_mday += (rtc7301_read(priv, RTC7301_10_DAY) & ~RTC7301_AE) * 10;
+
+ if (alarm) {
+ tm->tm_wday = -1;
+ tm->tm_mon = -1;
+ tm->tm_year = -1;
+ tm->tm_yday = -1;
+ tm->tm_isdst = -1;
+ return;
+ }
+
+ tm->tm_wday = (rtc7301_read(priv, RTC7301_DAY_OF_WEEK) & ~RTC7301_AE);
+ tm->tm_mon = rtc7301_read(priv, RTC7301_10_MONTH) * 10 +
+ rtc7301_read(priv, RTC7301_1_MONTH) - 1;
+ year = rtc7301_read(priv, RTC7301_1000_YEAR) * 1000 +
+ rtc7301_read(priv, RTC7301_100_YEAR) * 100 +
+ rtc7301_read(priv, RTC7301_10_YEAR) * 10 +
+ rtc7301_read(priv, RTC7301_1_YEAR);
+
+ tm->tm_year = year - 1900;
+}
+
+static void rtc7301_write_time(struct rtc7301_priv *priv, struct rtc_time *tm,
+ bool alarm)
+{
+ int year;
+
+ rtc7301_write(priv, tm->tm_sec % 10, RTC7301_1_SEC);
+ rtc7301_write(priv, tm->tm_sec / 10, RTC7301_10_SEC);
+
+ rtc7301_write(priv, tm->tm_min % 10, RTC7301_1_MIN);
+ rtc7301_write(priv, tm->tm_min / 10, RTC7301_10_MIN);
+
+ rtc7301_write(priv, tm->tm_hour % 10, RTC7301_1_HOUR);
+ rtc7301_write(priv, tm->tm_hour / 10, RTC7301_10_HOUR);
+
+ rtc7301_write(priv, tm->tm_mday % 10, RTC7301_1_DAY);
+ rtc7301_write(priv, tm->tm_mday / 10, RTC7301_10_DAY);
+
+ /* Don't care for alarm register */
+ rtc7301_write(priv, alarm ? RTC7301_AE : tm->tm_wday,
+ RTC7301_DAY_OF_WEEK);
+
+ if (alarm)
+ return;
+
+ rtc7301_write(priv, (tm->tm_mon + 1) % 10, RTC7301_1_MONTH);
+ rtc7301_write(priv, (tm->tm_mon + 1) / 10, RTC7301_10_MONTH);
+
+ year = tm->tm_year + 1900;
+
+ rtc7301_write(priv, year % 10, RTC7301_1_YEAR);
+ rtc7301_write(priv, (year / 10) % 10, RTC7301_10_YEAR);
+ rtc7301_write(priv, (year / 100) % 10, RTC7301_100_YEAR);
+ rtc7301_write(priv, year / 1000, RTC7301_1000_YEAR);
+}
+
+static void rtc7301_alarm_irq(struct rtc7301_priv *priv, unsigned int enabled)
+{
+ rtc7301_update_bits(priv, RTC7301_ALARM_CONTROL,
+ RTC7301_ALARM_CONTROL_AF |
+ RTC7301_ALARM_CONTROL_AIE,
+ enabled ? RTC7301_ALARM_CONTROL_AIE : 0);
+}
+
+static int rtc7301_read_time(struct device *dev, struct rtc_time *tm)
+{
+ struct rtc7301_priv *priv = dev_get_drvdata(dev);
+ unsigned long flags;
+ int err;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ rtc7301_select_bank(priv, 0);
+
+ err = rtc7301_wait_while_busy(priv);
+ if (!err)
+ rtc7301_get_time(priv, tm, false);
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return err ? err : rtc_valid_tm(tm);
+}
+
+static int rtc7301_set_time(struct device *dev, struct rtc_time *tm)
+{
+ struct rtc7301_priv *priv = dev_get_drvdata(dev);
+ unsigned long flags;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ rtc7301_stop(priv);
+ usleep_range(200, 300);
+ rtc7301_select_bank(priv, 0);
+ rtc7301_write_time(priv, tm, false);
+ rtc7301_start(priv);
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return 0;
+}
+
+static int rtc7301_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+ struct rtc7301_priv *priv = dev_get_drvdata(dev);
+ unsigned long flags;
+ u8 alrm_ctrl;
+
+ if (priv->irq <= 0)
+ return -EINVAL;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ rtc7301_select_bank(priv, 1);
+ rtc7301_get_time(priv, &alarm->time, true);
+
+ alrm_ctrl = rtc7301_read(priv, RTC7301_ALARM_CONTROL);
+
+ alarm->enabled = !!(alrm_ctrl & RTC7301_ALARM_CONTROL_AIE);
+ alarm->pending = !!(alrm_ctrl & RTC7301_ALARM_CONTROL_AF);
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return 0;
+}
+
+static int rtc7301_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+ struct rtc7301_priv *priv = dev_get_drvdata(dev);
+ unsigned long flags;
+
+ if (priv->irq <= 0)
+ return -EINVAL;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ rtc7301_select_bank(priv, 1);
+ rtc7301_write_time(priv, &alarm->time, true);
+ rtc7301_alarm_irq(priv, alarm->enabled);
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return 0;
+}
+
+static int rtc7301_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+ struct rtc7301_priv *priv = dev_get_drvdata(dev);
+ unsigned long flags;
+
+ if (priv->irq <= 0)
+ return -EINVAL;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ rtc7301_select_bank(priv, 1);
+ rtc7301_alarm_irq(priv, enabled);
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return 0;
+}
+
+static const struct rtc_class_ops rtc7301_rtc_ops = {
+ .read_time = rtc7301_read_time,
+ .set_time = rtc7301_set_time,
+ .read_alarm = rtc7301_read_alarm,
+ .set_alarm = rtc7301_set_alarm,
+ .alarm_irq_enable = rtc7301_alarm_irq_enable,
+};
+
+static irqreturn_t rtc7301_irq_handler(int irq, void *dev_id)
+{
+ struct rtc_device *rtc = dev_id;
+ struct rtc7301_priv *priv = dev_get_drvdata(rtc->dev.parent);
+ unsigned long flags;
+ irqreturn_t ret = IRQ_NONE;
+ u8 alrm_ctrl;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ rtc7301_select_bank(priv, 1);
+
+ alrm_ctrl = rtc7301_read(priv, RTC7301_ALARM_CONTROL);
+ if (alrm_ctrl & RTC7301_ALARM_CONTROL_AF) {
+ ret = IRQ_HANDLED;
+ rtc7301_alarm_irq(priv, false);
+ rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF);
+ }
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return ret;
+}
+
+static void rtc7301_init(struct rtc7301_priv *priv)
+{
+ unsigned long flags;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ rtc7301_select_bank(priv, 2);
+ rtc7301_write(priv, 0, RTC7301_TIMER_CONTROL);
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+static int __init rtc7301_rtc_probe(struct platform_device *dev)
+{
+ struct resource *res;
+ void __iomem *regs;
+ struct rtc7301_priv *priv;
+ struct rtc_device *rtc;
+ int ret;
+
+ res = platform_get_resource(dev, IORESOURCE_MEM, 0);
+ if (!res)
+ return -ENODEV;
+
+ priv = devm_kzalloc(&dev->dev, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
+ regs = devm_ioremap_resource(&dev->dev, res);
+ if (IS_ERR(regs))
+ return PTR_ERR(regs);
+
+ priv->regmap = devm_regmap_init_mmio(&dev->dev, regs,
+ &rtc7301_regmap_config);
+ if (IS_ERR(priv->regmap))
+ return PTR_ERR(priv->regmap);
+
+ priv->irq = platform_get_irq(dev, 0);
+
+ spin_lock_init(&priv->lock);
+ priv->bank = -1;
+
+ rtc7301_init(priv);
+
+ platform_set_drvdata(dev, priv);
+
+ rtc = devm_rtc_device_register(&dev->dev, DRV_NAME, &rtc7301_rtc_ops,
+ THIS_MODULE);
+ if (IS_ERR(rtc))
+ return PTR_ERR(rtc);
+
+ if (priv->irq > 0) {
+ ret = devm_request_irq(&dev->dev, priv->irq,
+ rtc7301_irq_handler, IRQF_SHARED,
+ dev_name(&dev->dev), rtc);
+ if (ret) {
+ priv->irq = 0;
+ dev_err(&dev->dev, "unable to request IRQ\n");
+ } else {
+ device_set_wakeup_capable(&dev->dev, true);
+ }
+ }
+
+ return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+
+static int rtc7301_suspend(struct device *dev)
+{
+ struct rtc7301_priv *priv = dev_get_drvdata(dev);
+
+ if (device_may_wakeup(dev))
+ enable_irq_wake(priv->irq);
+
+ return 0;
+}
+
+static int rtc7301_resume(struct device *dev)
+{
+ struct rtc7301_priv *priv = dev_get_drvdata(dev);
+
+ if (device_may_wakeup(dev))
+ disable_irq_wake(priv->irq);
+
+ return 0;
+}
+
+#endif
+
+static SIMPLE_DEV_PM_OPS(rtc7301_pm_ops, rtc7301_suspend, rtc7301_resume);
+
+static const struct of_device_id rtc7301_dt_match[] = {
+ { .compatible = "epson,rtc7301sf" },
+ { .compatible = "epson,rtc7301dg" },
+ {}
+};
+MODULE_DEVICE_TABLE(of, rtc7301_dt_match);
+
+static struct platform_driver rtc7301_rtc_driver = {
+ .driver = {
+ .name = DRV_NAME,
+ .of_match_table = rtc7301_dt_match,
+ .pm = &rtc7301_pm_ops,
+ },
+};
+
+module_platform_driver_probe(rtc7301_rtc_driver, rtc7301_rtc_probe);
+
+MODULE_AUTHOR("Akinobu Mita <akinobu.mita-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("EPSON TOYOCOM RTC-7301SF/DG Driver");
+MODULE_ALIAS("platform:rtc-r7301");
--
2.7.4
--
You received this message because you are subscribed to "rtc-linux".
Membership options at http://groups.google.com/group/rtc-linux .
Please read http://groups.google.com/group/rtc-linux/web/checklist
before submitting a driver.
---
You received this message because you are subscribed to the Google Groups "rtc-linux" group.
To unsubscribe from this group and stop receiving emails from it, send an email to rtc-linux+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/Ez6ZCGd0@public.gmane.org
For more options, visit https://groups.google.com/d/optout.
^ permalink raw reply related
* usb:xhci: support disable usb2 LPM Remote Wakeup
From: Thang Q. Nguyen @ 2016-12-04 12:42 UTC (permalink / raw)
To: Rob Herring, Pawel Moll, Mark Rutland, Ian Campbell, Kumar Gala,
Mathias Nyman, Greg Kroah-Hartman,
devicetree-u79uwXL29TY76Z2rM5mHXA,
linux-kernel-u79uwXL29TY76Z2rM5mHXA,
linux-usb-u79uwXL29TY76Z2rM5mHXA
Cc: Thang Nguyen, Phong Vo, Loc Ho, Vu Nguyen, patches-qTEPVZfXA3Y
From: Thang Nguyen <tqnguyen-qTEPVZfXA3Y@public.gmane.org>
As per USB 2.0 link power management addendum ECN, table 1-2, page 4,
device or host initiated via resume signaling; device-initiated resumes
can be optionally enabled/disabled by software. This patch adds support
to control enabling the USB2 RWE feature via DT/ACPI attribute.
Signed-off-by: Vu Nguyen <vnguyen-qTEPVZfXA3Y@public.gmane.org>
Signed-off-by: Thang Nguyen <tqnguyen-qTEPVZfXA3Y@public.gmane.org>
---
Documentation/devicetree/bindings/usb/usb-xhci.txt | 1 +
drivers/usb/host/xhci-plat.c | 3 +++
drivers/usb/host/xhci.c | 5 ++++-
drivers/usb/host/xhci.h | 1 +
4 files changed, 9 insertions(+), 1 deletion(-)
diff --git a/Documentation/devicetree/bindings/usb/usb-xhci.txt b/Documentation/devicetree/bindings/usb/usb-xhci.txt
index 966885c..9b4cd14 100644
--- a/Documentation/devicetree/bindings/usb/usb-xhci.txt
+++ b/Documentation/devicetree/bindings/usb/usb-xhci.txt
@@ -25,6 +25,7 @@ Required properties:
Optional properties:
- clocks: reference to a clock
+ - usb2-rwe-disable: disable USB2 LPM Remote Wakeup capable
- usb3-lpm-capable: determines if platform is USB3 LPM capable
Example:
diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index ed56bf9..15c540d 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -220,6 +220,9 @@ static int xhci_plat_probe(struct platform_device *pdev)
goto disable_clk;
}
+ if (device_property_read_bool(&pdev->dev, "usb2-rwe-disable"))
+ xhci->quirks |= XHCI_RWE_DISABLE;
+
if (device_property_read_bool(&pdev->dev, "usb3-lpm-capable"))
xhci->quirks |= XHCI_LPM_SUPPORT;
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 1a4ca02..f804868 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -4183,7 +4183,10 @@ int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
}
pm_val &= ~PORT_HIRD_MASK;
- pm_val |= PORT_HIRD(hird) | PORT_RWE | PORT_L1DS(udev->slot_id);
+ if ((xhci->quirks & XHCI_RWE_DISABLE) && (xhci->hci_version <= 0x100))
+ pm_val |= PORT_HIRD(hird) | PORT_L1DS(udev->slot_id);
+ else
+ pm_val |= PORT_HIRD(hird) | PORT_RWE | PORT_L1DS(udev->slot_id);
writel(pm_val, pm_addr);
pm_val = readl(pm_addr);
pm_val |= PORT_HLE;
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index f945380..2b9bc33 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -1656,6 +1656,7 @@ struct xhci_hcd {
#define XHCI_SSIC_PORT_UNUSED (1 << 22)
#define XHCI_NO_64BIT_SUPPORT (1 << 23)
#define XHCI_MISSING_CAS (1 << 24)
+#define XHCI_RWE_DISABLE (1 << 25)
unsigned int num_active_eps;
unsigned int limit_active_eps;
/* There are two roothubs to keep track of bus suspend info for */
--
2.7.4
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply related
* [PATCH] dts: sun8i-h3: correct UART3 pin definitions
From: jorik @ 2016-12-04 12:29 UTC (permalink / raw)
To: maxime.ripard, wens
Cc: mark.rutland, devicetree, linux, linux-kernel, linux-sunxi,
robh+dt, linux-arm-kernel, Jorik Jonker
From: Jorik Jonker <jorik@kippendief.biz>
In a previous commit, I made a copy/paste error in the pinmux
definitions of UART3: PG{13,14} instead of PA{13,14}. This commit takes
care of that. I have tested this commit on Orange Pi PC and Orange Pi
Plus, and it works for these boards.
Fixes: e3d11d3c45c5 ("dts: sun8i-h3: add pinmux definitions for
UART2-3")
Signed-off-by: Jorik Jonker <jorik@kippendief.biz>
---
arch/arm/boot/dts/sun8i-h3.dtsi | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/arch/arm/boot/dts/sun8i-h3.dtsi b/arch/arm/boot/dts/sun8i-h3.dtsi
index 75a8654..f4ba088 100644
--- a/arch/arm/boot/dts/sun8i-h3.dtsi
+++ b/arch/arm/boot/dts/sun8i-h3.dtsi
@@ -410,7 +410,7 @@
};
uart3_pins: uart3 {
- allwinner,pins = "PG13", "PG14";
+ allwinner,pins = "PA13", "PA14";
allwinner,function = "uart3";
allwinner,drive = <SUN4I_PINCTRL_10_MA>;
allwinner,pull = <SUN4I_PINCTRL_NO_PULL>;
--
2.9.3
^ permalink raw reply related
* Re: [PATCH 19/19] staging: iio: isl29028: remove legacy device tree binding
From: Jonathan Cameron @ 2016-12-04 11:55 UTC (permalink / raw)
To: Brian Masney, linux-iio
Cc: devel, devicetree, lars, gregkh, linux-kernel, Rob Herring,
ldewangan, pmeerw, knaack.h, Mark Rutland
In-Reply-To: <1480817983-32359-20-git-send-email-masneyb@onstation.org>
On 04/12/16 02:19, Brian Masney wrote:
> The isl29028 staging driver contains a legacy binding of "isl,isl29028"
> that is marked as legacy and to not use. There are no in tree references
> to that binding. This patch removes the legacy binding in preparation
> for moving the driver out of staging. Otherwise, we will have to support
> this binding indefinitely.
Leave this be. Given it exists there almost certainly device trees out there
using it. Lets not break them just to save on one line of code.
Supporting legacy bindings isn't exactly costly!
I'm happy with all the patches I haven't commented on. Just can't apply
them because they have dependencies on early patches that I have
raised questions on.
Another generally nice bit of cleanup.
Thanks,
Jonathan
>
> Signed-off-by: Brian Masney <masneyb@onstation.org>
> Cc: devicetree@vger.kernel.org
> Cc: Rob Herring <robh+dt@kernel.org>
> Cc: Mark Rutland <Mark.Rutland@arm.com>
> ---
> drivers/staging/iio/light/isl29028.c | 1 -
> 1 file changed, 1 deletion(-)
>
> diff --git a/drivers/staging/iio/light/isl29028.c b/drivers/staging/iio/light/isl29028.c
> index ae6896f..6be9aa7 100644
> --- a/drivers/staging/iio/light/isl29028.c
> +++ b/drivers/staging/iio/light/isl29028.c
> @@ -611,7 +611,6 @@ static const struct i2c_device_id isl29028_id[] = {
> MODULE_DEVICE_TABLE(i2c, isl29028_id);
>
> static const struct of_device_id isl29028_of_match[] = {
> - { .compatible = "isl,isl29028", }, /* for backward compat., don't use */
> { .compatible = "isil,isl29028", },
> { },
> };
>
^ permalink raw reply
* Re: [linux-sunxi] [PATCH v3 -next 2/2] ARM: dts: sunxi: add support for Orange Pi Zero board
From: Alexey Kardashevskiy @ 2016-12-04 8:12 UTC (permalink / raw)
To: Chen-Yu Tsai, Icenowy Zheng
Cc: devicetree, Vishnu Patekar, Arnd Bergmann,
linux-doc@vger.kernel.org, Andre Przywara, Russell King,
linux-kernel, Hans de Goede, linux-sunxi, Rob Herring,
Maxime Ripard, linux-arm-kernel
In-Reply-To: <CAGb2v661hBsd7tBcYByeRKEZh+8YMB3ewbnkrT3rUvzP2f90yQ@mail.gmail.com>
On 03/12/16 03:41, Chen-Yu Tsai wrote:
> Hi,
>
> On Fri, Dec 2, 2016 at 11:05 PM, Icenowy Zheng <icenowy@aosc.xyz> wrote:
>> Orange Pi Zero is a board that came with the new Allwinner H2+ SoC and a
>> SDIO Wi-Fi chip by Allwinner (XR819).
>>
>> Add a device tree file for it.
>>
>> Signed-off-by: Icenowy Zheng <icenowy@aosc.xyz>
>> ---
>> Changes since v2:
>> - Merged SDIO Wi-Fi patch into it.
>> - SDIO Wi-Fi: add a ethernet1 alias to it, as it has no internal NVRAM.
>> - SDIO Wi-Fi: changed pinctrl binding to generic pinconf
>> - removed all gpio pinctrl nodes
>> - changed h2plus to h2-plus
>> Changes since v1:
>> - Convert to generic pinconf bindings.
>> - SDIO Wi-Fi: add patch.
>>
>> Some notes:
>> - The uart1 and uart2 is available on the unsoldered gpio header.
>> - The onboard USB connector has its Vbus directly connected to DCIN-5V (the
>> power jack)
>>
>> arch/arm/boot/dts/Makefile | 1 +
>> arch/arm/boot/dts/sun8i-h2-plus-orangepi-zero.dts | 159 ++++++++++++++++++++++
>> 2 files changed, 160 insertions(+)
>> create mode 100644 arch/arm/boot/dts/sun8i-h2-plus-orangepi-zero.dts
>>
>> diff --git a/arch/arm/boot/dts/Makefile b/arch/arm/boot/dts/Makefile
>> index 6447abc..59f6e86 100644
>> --- a/arch/arm/boot/dts/Makefile
>> +++ b/arch/arm/boot/dts/Makefile
>> @@ -844,6 +844,7 @@ dtb-$(CONFIG_MACH_SUN8I) += \
>> sun8i-a33-sinlinx-sina33.dtb \
>> sun8i-a83t-allwinner-h8homlet-v2.dtb \
>> sun8i-a83t-cubietruck-plus.dtb \
>> + sun8i-h2-plus-orangepi-zero.dtb \
>> sun8i-h3-bananapi-m2-plus.dtb \
>> sun8i-h3-nanopi-neo.dtb \
>> sun8i-h3-orangepi-2.dtb \
>> diff --git a/arch/arm/boot/dts/sun8i-h2-plus-orangepi-zero.dts b/arch/arm/boot/dts/sun8i-h2-plus-orangepi-zero.dts
>> new file mode 100644
>> index 0000000..d18807f
>> --- /dev/null
>> +++ b/arch/arm/boot/dts/sun8i-h2-plus-orangepi-zero.dts
>> @@ -0,0 +1,159 @@
>> +/*
>> + * Copyright (C) 2016 Icenowy Zheng <icenowy@aosc.xyz>
>> + *
>> + * Based on sun8i-h3-orangepi-one.dts, which is:
>> + * Copyright (C) 2016 Hans de Goede <hdegoede@redhat.com>
>> + *
>> + * This file is dual-licensed: you can use it either under the terms
>> + * of the GPL or the X11 license, at your option. Note that this dual
>> + * licensing only applies to this file, and not this project as a
>> + * whole.
>> + *
>> + * a) This file 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.
>> + *
>> + * This file is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>> + * GNU General Public License for more details.
>> + *
>> + * Or, alternatively,
>> + *
>> + * b) Permission is hereby granted, free of charge, to any person
>> + * obtaining a copy of this software and associated documentation
>> + * files (the "Software"), to deal in the Software without
>> + * restriction, including without limitation the rights to use,
>> + * copy, modify, merge, publish, distribute, sublicense, and/or
>> + * sell copies of the Software, and to permit persons to whom the
>> + * Software is furnished to do so, subject to the following
>> + * conditions:
>> + *
>> + * The above copyright notice and this permission notice shall be
>> + * included in all copies or substantial portions of the Software.
>> + *
>> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
>> + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
>> + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
>> + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
>> + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
>> + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
>> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
>> + * OTHER DEALINGS IN THE SOFTWARE.
>> + */
>> +
>> +/dts-v1/;
>> +#include "sun8i-h3.dtsi"
>> +#include "sunxi-common-regulators.dtsi"
>> +
>> +#include <dt-bindings/gpio/gpio.h>
>> +#include <dt-bindings/input/input.h>
>> +#include <dt-bindings/pinctrl/sun4i-a10.h>
>> +
>> +/ {
>> + model = "Xunlong Orange Pi Zero";
>> + compatible = "xunlong,orangepi-zero", "allwinner,sun8i-h2-plus";
>> +
>> + aliases {
>> + serial0 = &uart0;
>> + /* ethernet0 is the H3 emac, defined in sun8i-h3.dtsi */
>> + ethernet1 = &xr819;
>> + };
>> +
>> + chosen {
>> + stdout-path = "serial0:115200n8";
>> + };
>> +
>> + leds {
>> + compatible = "gpio-leds";
>> +
>> + pwr_led {
>> + label = "orangepi:green:pwr";
>> + gpios = <&r_pio 0 10 GPIO_ACTIVE_HIGH>;
>> + default-state = "on";
>> + };
>> +
>> + status_led {
>> + label = "orangepi:red:status";
>> + gpios = <&pio 0 17 GPIO_ACTIVE_HIGH>;
>> + };
>> + };
>> +
>> + reg_vcc_wifi: reg_vcc_wifi {
>> + compatible = "regulator-fixed";
>> + regulator-min-microvolt = <3300000>;
>> + regulator-max-microvolt = <3300000>;
>> + regulator-name = "vcc-wifi";
>> + enable-active-high;
>> + gpio = <&pio 0 20 GPIO_ACTIVE_HIGH>;
>> + };
>> +
>> + wifi_pwrseq: wifi_pwrseq {
>> + compatible = "mmc-pwrseq-simple";
>> + reset-gpios = <&r_pio 0 7 GPIO_ACTIVE_LOW>;
>> + };
>> +};
>> +
>> +&ehci1 {
>> + status = "okay";
>> +};
>> +
>> +&mmc0 {
>> + pinctrl-names = "default";
>> + pinctrl-0 = <&mmc0_pins_a>;
>> + vmmc-supply = <®_vcc3v3>;
>> + bus-width = <4>;
>> + cd-gpios = <&pio 5 6 GPIO_ACTIVE_HIGH>; /* PF6 */
>> + cd-inverted;
>> + status = "okay";
>> +};
>> +
>> +&mmc1 {
>> + pinctrl-names = "default";
>> + pinctrl-0 = <&mmc1_pins_a>;
>> + vmmc-supply = <®_vcc_wifi>;
>> + mmc-pwrseq = <&wifi_pwrseq>;
>> + bus-width = <4>;
>> + non-removable;
>> + status = "okay";
>> +
>> + /*
>> + * Explicitly define the sdio device, so that we can add an ethernet
>> + * alias for it (which e.g. makes u-boot set a mac-address).
>> + */
>> + xr819: sdio_wifi@1 {
>> + reg = <1>;
>> + };
>> +};
>> +
>> +&mmc1_pins_a {
>> + bias-pull-up;
>
> This is already set in h3.dtsi
>
>> +};
>> +
>> +&ohci1 {
>> + status = "okay";
>> +};
>> +
>> +&uart0 {
>> + pinctrl-names = "default";
>> + pinctrl-0 = <&uart0_pins_a>;
>> + status = "okay";
>> +};
>> +
>> +&uart1 {
>> + pinctrl-names = "default";
>> + pinctrl-0 = <&uart1_pins>;
>> + status = "disabled";
>> +};
>> +
>> +&uart2 {
>> + pinctrl-names = "default";
>> + pinctrl-0 = <&uart2_pins>;
>> + status = "disabled";
>> +};
>> +
>> +&usbphy {
>> + /* USB VBUS is always on */
>
> I think this comment could use a little work.
>
> AFAIK this board doesn't have an actual USB port.
Mine does have one port.
> It's just the D+/D- pins on the pin header, along
> with the board-wide 5V, also on the pin header.
>
> ChenYu
>
>> + status = "okay";
>> +};
>> --
>> 2.10.2
>>
>> --
>> You received this message because you are subscribed to the Google Groups "linux-sunxi" group.
>> To unsubscribe from this group and stop receiving emails from it, send an email to linux-sunxi+unsubscribe@googlegroups.com.
>> For more options, visit https://groups.google.com/d/optout.
--
Alexey
^ permalink raw reply
* Re: [PATCH v3 07/13] net: ethernet: ti: cpts: clean up event list if event pool is empty
From: kbuild test robot @ 2016-12-04 6:09 UTC (permalink / raw)
Cc: kbuild-all-JC7UmRfGjtg, David S. Miller,
netdev-u79uwXL29TY76Z2rM5mHXA, Mugunthan V N, Richard Cochran,
Sekhar Nori, linux-kernel-u79uwXL29TY76Z2rM5mHXA,
linux-omap-u79uwXL29TY76Z2rM5mHXA, Rob Herring,
devicetree-u79uwXL29TY76Z2rM5mHXA, Murali Karicheri, Wingman Kwok,
Thomas Gleixner, Grygorii Strashko
In-Reply-To: <20161202203023.25526-8-grygorii.strashko-l0cyMroinI0@public.gmane.org>
[-- Attachment #1: Type: text/plain, Size: 3916 bytes --]
Hi WingMan,
[auto build test ERROR on net/master]
[also build test ERROR on v4.9-rc7 next-20161202]
[cannot apply to net-next/master]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]
url: https://github.com/0day-ci/linux/commits/Grygorii-Strashko/net-ethernet-ti-cpts-switch-to-readl-writel_relaxed/20161204-010355
config: arm-omap2plus_defconfig (attached as .config)
compiler: arm-linux-gnueabi-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
wget https://git.kernel.org/cgit/linux/kernel/git/wfg/lkp-tests.git/plain/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
make.cross ARCH=arm
Note: the linux-review/Grygorii-Strashko/net-ethernet-ti-cpts-switch-to-readl-writel_relaxed/20161204-010355 HEAD f938805dce662197c057c75ac67849f60da87c9f builds fine.
It only hurts bisectibility.
All errors (new ones prefixed by >>):
In file included from include/linux/dma-mapping.h:6:0,
from include/linux/skbuff.h:34,
from include/linux/ip.h:20,
from include/linux/ptp_classify.h:26,
from drivers/net/ethernet/ti/cpts.c:25:
drivers/net/ethernet/ti/cpts.c: In function 'cpts_purge_events':
>> drivers/net/ethernet/ti/cpts.c:76:15: error: 'struct cpts' has no member named 'dev'
dev_dbg(cpts->dev, "cpts: event pool cleaned up %d\n", removed);
^
include/linux/device.h:1209:26: note: in definition of macro 'dev_dbg'
dev_printk(KERN_DEBUG, dev, format, ##arg); \
^~~
drivers/net/ethernet/ti/cpts.c: In function 'cpts_fifo_read':
drivers/net/ethernet/ti/cpts.c:94:16: error: 'struct cpts' has no member named 'dev'
dev_err(cpts->dev, "cpts: event pool empty\n");
^~
vim +76 drivers/net/ethernet/ti/cpts.c
19 */
20 #include <linux/err.h>
21 #include <linux/if.h>
22 #include <linux/hrtimer.h>
23 #include <linux/module.h>
24 #include <linux/net_tstamp.h>
> 25 #include <linux/ptp_classify.h>
26 #include <linux/time.h>
27 #include <linux/uaccess.h>
28 #include <linux/workqueue.h>
29 #include <linux/if_ether.h>
30 #include <linux/if_vlan.h>
31
32 #include "cpts.h"
33
34 #define cpts_read32(c, r) readl_relaxed(&c->reg->r)
35 #define cpts_write32(c, v, r) writel_relaxed(v, &c->reg->r)
36
37 static int event_expired(struct cpts_event *event)
38 {
39 return time_after(jiffies, event->tmo);
40 }
41
42 static int event_type(struct cpts_event *event)
43 {
44 return (event->high >> EVENT_TYPE_SHIFT) & EVENT_TYPE_MASK;
45 }
46
47 static int cpts_fifo_pop(struct cpts *cpts, u32 *high, u32 *low)
48 {
49 u32 r = cpts_read32(cpts, intstat_raw);
50
51 if (r & TS_PEND_RAW) {
52 *high = cpts_read32(cpts, event_high);
53 *low = cpts_read32(cpts, event_low);
54 cpts_write32(cpts, EVENT_POP, event_pop);
55 return 0;
56 }
57 return -1;
58 }
59
60 static int cpts_purge_events(struct cpts *cpts)
61 {
62 struct list_head *this, *next;
63 struct cpts_event *event;
64 int removed = 0;
65
66 list_for_each_safe(this, next, &cpts->events) {
67 event = list_entry(this, struct cpts_event, list);
68 if (event_expired(event)) {
69 list_del_init(&event->list);
70 list_add(&event->list, &cpts->pool);
71 ++removed;
72 }
73 }
74
75 if (removed)
> 76 dev_dbg(cpts->dev, "cpts: event pool cleaned up %d\n", removed);
77 return removed ? 0 : -1;
78 }
79
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 28475 bytes --]
^ permalink raw reply
* Re: [PATCH] dt-binding: soc: qcom: smd: Add label property
From: Andy Gross @ 2016-12-04 4:26 UTC (permalink / raw)
To: Rob Herring
Cc: Bjorn Andersson, David Brown, Mark Rutland, linux-arm-msm,
linux-soc, devicetree, linux-kernel
In-Reply-To: <20161026220820.4wsxyyakucmrnkvj@rob-hp-laptop>
On Wed, Oct 26, 2016 at 05:08:20PM -0500, Rob Herring wrote:
> On Wed, Oct 19, 2016 at 07:38:10PM -0700, Bjorn Andersson wrote:
> > The label property can be used to specify a name of the edge, for
> > consistent naming purposes.
> >
> > Signed-off-by: Bjorn Andersson <bjorn.andersson@linaro.org>
> > ---
> > Documentation/devicetree/bindings/soc/qcom/qcom,smd.txt | 7 +++++++
> > 1 file changed, 7 insertions(+)
>
> Acked-by: Rob Herring <robh@kernel.org>
Acked-by: Andy Gross <andy.gross@linaro.org>
^ permalink raw reply
* Re: [PATCH V4 2/2] pinctrl: tegra: Add driver to configure voltage and power of io pads
From: kbuild test robot @ 2016-12-04 3:31 UTC (permalink / raw)
Cc: kbuild-all, linus.walleij, robh+dt, mark.rutland, swarren,
thierry.reding, gnurou, jonathanh, joe, yamada.masahiro,
linux-gpio, devicetree, linux-tegra, linux-kernel,
Laxman Dewangan
In-Reply-To: <1479976734-30498-3-git-send-email-ldewangan@nvidia.com>
[-- Attachment #1: Type: text/plain, Size: 1731 bytes --]
Hi Laxman,
[auto build test ERROR on tegra/for-next]
[also build test ERROR on v4.9-rc7 next-20161202]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]
url: https://github.com/0day-ci/linux/commits/Laxman-Dewangan/pinctrl-tegra-Add-DT-binding-for-io-pads-control/20161124-185652
base: https://git.kernel.org/pub/scm/linux/kernel/git/tegra/linux.git for-next
config: arm-allmodconfig (attached as .config)
compiler: arm-linux-gnueabi-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
wget https://git.kernel.org/cgit/linux/kernel/git/wfg/lkp-tests.git/plain/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
make.cross ARCH=arm
All errors (new ones prefixed by >>):
drivers/pinctrl/tegra/pinctrl-tegra-io-pad.c: In function 'tegra_io_pads_pinconf_get':
>> drivers/pinctrl/tegra/pinctrl-tegra-io-pad.c:124:9: error: implicit declaration of function 'tegra_io_pad_power_get_status' [-Werror=implicit-function-declaration]
ret = tegra_io_pad_power_get_status(cfg->id);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
cc1: some warnings being treated as errors
vim +/tegra_io_pad_power_get_status +124 drivers/pinctrl/tegra/pinctrl-tegra-io-pad.c
118 dev_err(tiopi->dev,
119 "IO pad %s does not support low power\n",
120 cfg->name);
121 return -EINVAL;
122 }
123
> 124 ret = tegra_io_pad_power_get_status(cfg->id);
125 if (ret < 0)
126 return ret;
127 arg = !ret;
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 59453 bytes --]
^ permalink raw reply
* [PATCH 19/19] staging: iio: isl29028: remove legacy device tree binding
From: Brian Masney @ 2016-12-04 2:19 UTC (permalink / raw)
To: jic23, linux-iio
Cc: devel, devicetree, lars, gregkh, linux-kernel, Rob Herring,
ldewangan, pmeerw, knaack.h, Mark Rutland
In-Reply-To: <1480817983-32359-1-git-send-email-masneyb@onstation.org>
The isl29028 staging driver contains a legacy binding of "isl,isl29028"
that is marked as legacy and to not use. There are no in tree references
to that binding. This patch removes the legacy binding in preparation
for moving the driver out of staging. Otherwise, we will have to support
this binding indefinitely.
Signed-off-by: Brian Masney <masneyb@onstation.org>
Cc: devicetree@vger.kernel.org
Cc: Rob Herring <robh+dt@kernel.org>
Cc: Mark Rutland <Mark.Rutland@arm.com>
---
drivers/staging/iio/light/isl29028.c | 1 -
1 file changed, 1 deletion(-)
diff --git a/drivers/staging/iio/light/isl29028.c b/drivers/staging/iio/light/isl29028.c
index ae6896f..6be9aa7 100644
--- a/drivers/staging/iio/light/isl29028.c
+++ b/drivers/staging/iio/light/isl29028.c
@@ -611,7 +611,6 @@ static const struct i2c_device_id isl29028_id[] = {
MODULE_DEVICE_TABLE(i2c, isl29028_id);
static const struct of_device_id isl29028_of_match[] = {
- { .compatible = "isl,isl29028", }, /* for backward compat., don't use */
{ .compatible = "isil,isl29028", },
{ },
};
--
2.7.4
^ permalink raw reply related
* Re: [PATCH 3/6] net: ethernet: ti: cpts: add support of cpts HW_TS_PUSH
From: Richard Cochran @ 2016-12-03 23:21 UTC (permalink / raw)
To: Grygorii Strashko
Cc: David S. Miller, netdev, Mugunthan V N, Sekhar Nori, linux-kernel,
linux-omap, Rob Herring, devicetree, Murali Karicheri,
Wingman Kwok
In-Reply-To: <20161128230428.6872-4-grygorii.strashko@ti.com>
On Mon, Nov 28, 2016 at 05:04:25PM -0600, Grygorii Strashko wrote:
> This also change overflow polling period when HW_TS_PUSH feature is
> enabled - overflow check work will be scheduled more often (every
> 200ms) for proper HW_TS_PUSH events reporting.
For proper reporting, you should make use of the interrupt. The small
fifo (16 iirc) could very well overflow in 200 ms. The interrupt
handler should read out the entire fifo at each interrupt.
Thanks,
Richard
^ permalink raw reply
* Re: [PATCH] ARM: dts: sunxi: Add num-cs for A20 spi nodes
From: kbuild test robot @ 2016-12-03 23:10 UTC (permalink / raw)
Cc: kbuild-all-JC7UmRfGjtg, robh+dt-DgEjT+Ai2ygdnm+yROfE0A,
mark.rutland-5wv7dgnIgG8, linux-I+IVW8TIWO2tmTQ+vhA3Yw,
maxime.ripard-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8, wens-jdAy2FN1RRM,
devicetree-u79uwXL29TY76Z2rM5mHXA,
linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r,
linux-kernel-u79uwXL29TY76Z2rM5mHXA, Emmanuel Vadot
In-Reply-To: <20161122170616.29557-1-manu-xXdDKFdH5B3kFDPD4ZthVA@public.gmane.org>
[-- Attachment #1: Type: text/plain, Size: 1083 bytes --]
Hi Emmanuel,
[auto build test ERROR on robh/for-next]
[also build test ERROR on v4.9-rc7 next-20161202]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]
url: https://github.com/0day-ci/linux/commits/Emmanuel-Vadot/ARM-dts-sunxi-Add-num-cs-for-A20-spi-nodes/20161123-034323
base: https://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git for-next
config: arm-vexpress_defconfig (attached as .config)
compiler: arm-linux-gnueabi-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
wget https://git.kernel.org/cgit/linux/kernel/git/wfg/lkp-tests.git/plain/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
make.cross ARCH=arm
All errors (new ones prefixed by >>):
>> Error: arch/arm/boot/dts/sun7i-a20.dtsi:874.13-14 syntax error
>> FATAL ERROR: Unable to parse input tree
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 18504 bytes --]
^ permalink raw reply
* Re: [RFC PATCH 2/2] Documentation: devictree: Add macb mdio bindings
From: Florian Fainelli @ 2016-12-03 22:40 UTC (permalink / raw)
To: Rob Herring, Harini Katakam
Cc: nicolas.ferre, davem, pawel.moll, mark.rutland, ijc+devicetree,
galak, boris.brezillon, alexandre.belloni, harinikatakamlinux,
netdev, linux-kernel, devicetree, harinik, michals
In-Reply-To: <20161203213553.f3agwvaseufglnq6@rob-hp-laptop>
Le 12/03/16 à 13:35, Rob Herring a écrit :
> On Mon, Nov 28, 2016 at 03:19:27PM +0530, Harini Katakam wrote:
>> Add documentations for macb mdio driver.
>
> Bindings document h/w, not drivers.
>
>>
>> Signed-off-by: Harini Katakam <harinik@xilinx.com>
>> ---
>> .../devicetree/bindings/net/macb-mdio.txt | 31 ++++++++++++++++++++++
>> 1 file changed, 31 insertions(+)
>> create mode 100644 Documentation/devicetree/bindings/net/macb-mdio.txt
>>
>> diff --git a/Documentation/devicetree/bindings/net/macb-mdio.txt b/Documentation/devicetree/bindings/net/macb-mdio.txt
>> new file mode 100644
>> index 0000000..014cedf
>> --- /dev/null
>> +++ b/Documentation/devicetree/bindings/net/macb-mdio.txt
>> @@ -0,0 +1,31 @@
>> +* Cadence MACB MDIO controller
>> +
>> +Required properties:
>> +- compatible: Should be "cdns,macb-mdio"
>
> Only one version ever? This needs more specific compatible strings.
>
>> +- reg: Address and length of the register set of MAC to be used
>> +- clock-names: Tuple listing input clock names.
>> + Required elements: 'pclk', 'hclk'
>> + Optional elements: 'tx_clk'
>> +- clocks: Phandles to input clocks.
You are also missing mandatory properties:
#address-cells = <1> and #size-cells = <0>
Where is patch 1? Can you make sure you have the same recipient list for
both patches in this series so we can review both the binding and driver?
Thanks!
--
Florian
^ permalink raw reply
* [PATCH v2 3/3] ARM: dts: vf610-zii-dev-rev-b: Remove 'fixed-link' from DSA ports
From: Andrey Smirnov @ 2016-12-03 22:30 UTC (permalink / raw)
To: linux-arm-kernel
Cc: Andrey Smirnov, Shawn Guo, Rob Herring, Mark Rutland,
Russell King, Sascha Hauer, Stefan Agner, devicetree,
linux-kernel, andrew, cphealy
In-Reply-To: <1480804219-12596-1-git-send-email-andrew.smirnov@gmail.com>
Remove 'fixed-link' nodes from DSA ports since they are not needed (they
are not limiting link's speed and the ports will be configured to their
maximux speed as a default)
Suggested-by: Andrew Lunn <andrew@lunn.ch>
Signed-off-by: Andrey Smirnov <andrew.smirnov@gmail.com>
---
Changes since v1:
- Patch was not present in v1
arch/arm/boot/dts/vf610-zii-dev-rev-b.dts | 8 --------
1 file changed, 8 deletions(-)
diff --git a/arch/arm/boot/dts/vf610-zii-dev-rev-b.dts b/arch/arm/boot/dts/vf610-zii-dev-rev-b.dts
index c0fc3f2..646c90c 100644
--- a/arch/arm/boot/dts/vf610-zii-dev-rev-b.dts
+++ b/arch/arm/boot/dts/vf610-zii-dev-rev-b.dts
@@ -97,10 +97,6 @@
phy-mode = "rgmii-txid";
link = <&switch1port6
&switch2port9>;
- fixed-link {
- speed = <1000>;
- full-duplex;
- };
};
port@6 {
@@ -165,10 +161,6 @@
label = "dsa";
phy-mode = "rgmii-txid";
link = <&switch0port5>;
- fixed-link {
- speed = <1000>;
- full-duplex;
- };
};
};
mdio {
--
2.5.5
^ permalink raw reply related
* [PATCH v2 2/3] ARM: dts: vf610-zii-dev: Add .dts file for rev. C
From: Andrey Smirnov @ 2016-12-03 22:30 UTC (permalink / raw)
To: linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r
Cc: Andrey Smirnov, Shawn Guo, Rob Herring, Mark Rutland,
Russell King, Sascha Hauer, Stefan Agner,
devicetree-u79uwXL29TY76Z2rM5mHXA,
linux-kernel-u79uwXL29TY76Z2rM5mHXA, andrew-g2DYL2Zd6BY,
cphealy-Re5JQEeQqe8AvxtiuMwx3w
In-Reply-To: <1480804219-12596-1-git-send-email-andrew.smirnov-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>
Add .dts file for rev. C of the board by factoring out commonalities
into a shared include file (vf610-zii-dev.dtsi) and deriving revision
specific file from it (vf610-zii-dev-rev-b.dts and
vf610-zii-dev-reb-c.dts).
Signed-off-by: Andrey Smirnov <andrew.smirnov-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>
---
Changes since v1:
- Removed fixed-link nodes from switch{0,1}port10
- Changed compatiblity for switch0 to "marvell,mv88e6190"
- Removde port@9 from swith0 as well as mdio node
- Renamed shared .dtsi to "vf610-zii-dev.dtsi", since same
basic deign is shared by more than Rev. B and Rev
C. development boards
arch/arm/boot/dts/Makefile | 3 +-
arch/arm/boot/dts/vf610-zii-dev-rev-b.dts | 300 +----------------------
arch/arm/boot/dts/vf610-zii-dev-rev-c.dts | 394 ++++++++++++++++++++++++++++++
arch/arm/boot/dts/vf610-zii-dev.dtsi | 383 +++++++++++++++++++++++++++++
4 files changed, 780 insertions(+), 300 deletions(-)
create mode 100644 arch/arm/boot/dts/vf610-zii-dev-rev-c.dts
create mode 100644 arch/arm/boot/dts/vf610-zii-dev.dtsi
diff --git a/arch/arm/boot/dts/Makefile b/arch/arm/boot/dts/Makefile
index befcd26..9f0d2a1 100644
--- a/arch/arm/boot/dts/Makefile
+++ b/arch/arm/boot/dts/Makefile
@@ -442,7 +442,8 @@ dtb-$(CONFIG_SOC_VF610) += \
vf610-cosmic.dtb \
vf610m4-cosmic.dtb \
vf610-twr.dtb \
- vf610-zii-dev-rev-b.dtb
+ vf610-zii-dev-rev-b.dtb \
+ vf610-zii-dev-rev-c.dtb
dtb-$(CONFIG_ARCH_MXS) += \
imx23-evk.dtb \
imx23-olinuxino.dtb \
diff --git a/arch/arm/boot/dts/vf610-zii-dev-rev-b.dts b/arch/arm/boot/dts/vf610-zii-dev-rev-b.dts
index 2210811..c0fc3f2 100644
--- a/arch/arm/boot/dts/vf610-zii-dev-rev-b.dts
+++ b/arch/arm/boot/dts/vf610-zii-dev-rev-b.dts
@@ -43,32 +43,12 @@
*/
/dts-v1/;
-#include "vf610.dtsi"
+#include "vf610-zii-dev.dtsi"
/ {
model = "ZII VF610 Development Board, Rev B";
compatible = "zii,vf610dev-b", "zii,vf610dev", "fsl,vf610";
- chosen {
- stdout-path = "serial0:115200n8";
- };
-
- memory {
- reg = <0x80000000 0x20000000>;
- };
-
- gpio-leds {
- compatible = "gpio-leds";
- pinctrl-0 = <&pinctrl_leds_debug>;
- pinctrl-names = "default";
-
- debug {
- label = "zii:green:debug1";
- gpios = <&gpio2 10 GPIO_ACTIVE_HIGH>;
- linux,default-trigger = "heartbeat";
- };
- };
-
mdio-mux {
compatible = "mdio-mux-gpio";
pinctrl-0 = <&pinctrl_mdio_mux>;
@@ -281,25 +261,6 @@
};
};
- reg_vcc_3v3_mcu: regulator-vcc-3v3-mcu {
- compatible = "regulator-fixed";
- regulator-name = "vcc_3v3_mcu";
- regulator-min-microvolt = <3300000>;
- regulator-max-microvolt = <3300000>;
- };
-
- usb0_vbus: regulator-usb0-vbus {
- compatible = "regulator-fixed";
- pinctrl-0 = <&pinctrl_usb_vbus>;
- regulator-name = "usb_vbus";
- regulator-min-microvolt = <5000000>;
- regulator-max-microvolt = <5000000>;
- enable-active-high;
- regulator-always-on;
- regulator-boot-on;
- gpio = <&gpio0 6 0>;
- };
-
spi0 {
compatible = "spi-gpio";
pinctrl-0 = <&pinctrl_gpio_spi0>;
@@ -336,49 +297,6 @@
};
};
-&adc0 {
- pinctrl-names = "default";
- pinctrl-0 = <&pinctrl_adc0_ad5>;
- vref-supply = <®_vcc_3v3_mcu>;
- status = "okay";
-};
-
-&edma0 {
- status = "okay";
-};
-
-&esdhc1 {
- pinctrl-names = "default";
- pinctrl-0 = <&pinctrl_esdhc1>;
- bus-width = <4>;
- status = "okay";
-};
-
-&fec0 {
- phy-mode = "rmii";
- pinctrl-names = "default";
- pinctrl-0 = <&pinctrl_fec0>;
- status = "okay";
-};
-
-&fec1 {
- phy-mode = "rmii";
- pinctrl-names = "default";
- pinctrl-0 = <&pinctrl_fec1>;
- status = "okay";
-
- fixed-link {
- speed = <100>;
- full-duplex;
- };
-
- mdio1: mdio {
- #address-cells = <1>;
- #size-cells = <0>;
- status = "okay";
- };
-};
-
&i2c0 {
clock-frequency = <100000>;
pinctrl-names = "default";
@@ -403,33 +321,6 @@
interrupt-parent = <&gpio2>;
interrupts = <2 IRQ_TYPE_LEVEL_LOW>;
};
-
- lm75@48 {
- compatible = "national,lm75";
- reg = <0x48>;
- };
-
- at24c04@50 {
- compatible = "atmel,24c04";
- reg = <0x50>;
- };
-
- at24c04@52 {
- compatible = "atmel,24c04";
- reg = <0x52>;
- };
-
- ds1682@6b {
- compatible = "dallas,ds1682";
- reg = <0x6b>;
- };
-};
-
-&i2c1 {
- clock-frequency = <100000>;
- pinctrl-names = "default";
- pinctrl-0 = <&pinctrl_i2c1>;
- status = "okay";
};
&i2c2 {
@@ -499,120 +390,8 @@
};
};
-&uart0 {
- pinctrl-names = "default";
- pinctrl-0 = <&pinctrl_uart0>;
- status = "okay";
-};
-
-&uart1 {
- pinctrl-names = "default";
- pinctrl-0 = <&pinctrl_uart1>;
- status = "okay";
-};
-
-&uart2 {
- pinctrl-names = "default";
- pinctrl-0 = <&pinctrl_uart2>;
- status = "okay";
-};
-
-&usbdev0 {
- disable-over-current;
- vbus-supply = <&usb0_vbus>;
- dr_mode = "host";
- status = "okay";
-};
-
-&usbh1 {
- disable-over-current;
- status = "okay";
-};
-
-&usbmisc0 {
- status = "okay";
-};
-
-&usbmisc1 {
- status = "okay";
-};
-
-&usbphy0 {
- status = "okay";
-};
-
-&usbphy1 {
- status = "okay";
-};
&iomuxc {
- pinctrl_adc0_ad5: adc0ad5grp {
- fsl,pins = <
- VF610_PAD_PTC30__ADC0_SE5 0x00a1
- >;
- };
-
- pinctrl_dspi0: dspi0grp {
- fsl,pins = <
- VF610_PAD_PTB18__DSPI0_CS1 0x1182
- VF610_PAD_PTB19__DSPI0_CS0 0x1182
- VF610_PAD_PTB20__DSPI0_SIN 0x1181
- VF610_PAD_PTB21__DSPI0_SOUT 0x1182
- VF610_PAD_PTB22__DSPI0_SCK 0x1182
- >;
- };
-
- pinctrl_dspi2: dspi2grp {
- fsl,pins = <
- VF610_PAD_PTD31__DSPI2_CS1 0x1182
- VF610_PAD_PTD30__DSPI2_CS0 0x1182
- VF610_PAD_PTD29__DSPI2_SIN 0x1181
- VF610_PAD_PTD28__DSPI2_SOUT 0x1182
- VF610_PAD_PTD27__DSPI2_SCK 0x1182
- >;
- };
-
- pinctrl_esdhc1: esdhc1grp {
- fsl,pins = <
- VF610_PAD_PTA24__ESDHC1_CLK 0x31ef
- VF610_PAD_PTA25__ESDHC1_CMD 0x31ef
- VF610_PAD_PTA26__ESDHC1_DAT0 0x31ef
- VF610_PAD_PTA27__ESDHC1_DAT1 0x31ef
- VF610_PAD_PTA28__ESDHC1_DATA2 0x31ef
- VF610_PAD_PTA29__ESDHC1_DAT3 0x31ef
- VF610_PAD_PTA7__GPIO_134 0x219d
- >;
- };
-
- pinctrl_fec0: fec0grp {
- fsl,pins = <
- VF610_PAD_PTC0__ENET_RMII0_MDC 0x30d2
- VF610_PAD_PTC1__ENET_RMII0_MDIO 0x30d3
- VF610_PAD_PTC2__ENET_RMII0_CRS 0x30d1
- VF610_PAD_PTC3__ENET_RMII0_RXD1 0x30d1
- VF610_PAD_PTC4__ENET_RMII0_RXD0 0x30d1
- VF610_PAD_PTC5__ENET_RMII0_RXER 0x30d1
- VF610_PAD_PTC6__ENET_RMII0_TXD1 0x30d2
- VF610_PAD_PTC7__ENET_RMII0_TXD0 0x30d2
- VF610_PAD_PTC8__ENET_RMII0_TXEN 0x30d2
- >;
- };
-
- pinctrl_fec1: fec1grp {
- fsl,pins = <
- VF610_PAD_PTA6__RMII_CLKIN 0x30d1
- VF610_PAD_PTC9__ENET_RMII1_MDC 0x30d2
- VF610_PAD_PTC10__ENET_RMII1_MDIO 0x30d3
- VF610_PAD_PTC11__ENET_RMII1_CRS 0x30d1
- VF610_PAD_PTC12__ENET_RMII1_RXD1 0x30d1
- VF610_PAD_PTC13__ENET_RMII1_RXD0 0x30d1
- VF610_PAD_PTC14__ENET_RMII1_RXER 0x30d1
- VF610_PAD_PTC15__ENET_RMII1_TXD1 0x30d2
- VF610_PAD_PTC16__ENET_RMII1_TXD0 0x30d2
- VF610_PAD_PTC17__ENET_RMII1_TXEN 0x30d2
- >;
- };
-
pinctrl_gpio_e6185_eeprom_sel: pinctrl-gpio-e6185-eeprom-spi0 {
fsl,pins = <
VF610_PAD_PTE27__GPIO_132 0x33e2
@@ -629,39 +408,6 @@
>;
};
- pinctrl_i2c_mux_reset: pinctrl-i2c-mux-reset {
- fsl,pins = <
- VF610_PAD_PTE14__GPIO_119 0x31c2
- >;
- };
-
- pinctrl_i2c0: i2c0grp {
- fsl,pins = <
- VF610_PAD_PTB14__I2C0_SCL 0x37ff
- VF610_PAD_PTB15__I2C0_SDA 0x37ff
- >;
- };
-
- pinctrl_i2c1: i2c1grp {
- fsl,pins = <
- VF610_PAD_PTB16__I2C1_SCL 0x37ff
- VF610_PAD_PTB17__I2C1_SDA 0x37ff
- >;
- };
-
- pinctrl_i2c2: i2c2grp {
- fsl,pins = <
- VF610_PAD_PTA22__I2C2_SCL 0x37ff
- VF610_PAD_PTA23__I2C2_SDA 0x37ff
- >;
- };
-
- pinctrl_leds_debug: pinctrl-leds-debug {
- fsl,pins = <
- VF610_PAD_PTD20__GPIO_74 0x31c2
- >;
- };
-
pinctrl_mdio_mux: pinctrl-mdio-mux {
fsl,pins = <
VF610_PAD_PTA18__GPIO_8 0x31c2
@@ -676,48 +422,4 @@
VF610_PAD_PTB28__GPIO_98 0x219d
>;
};
-
- pinctrl_qspi0: qspi0grp {
- fsl,pins = <
- VF610_PAD_PTD7__QSPI0_B_QSCK 0x31c3
- VF610_PAD_PTD8__QSPI0_B_CS0 0x31ff
- VF610_PAD_PTD9__QSPI0_B_DATA3 0x31c3
- VF610_PAD_PTD10__QSPI0_B_DATA2 0x31c3
- VF610_PAD_PTD11__QSPI0_B_DATA1 0x31c3
- VF610_PAD_PTD12__QSPI0_B_DATA0 0x31c3
- >;
- };
-
- pinctrl_uart0: uart0grp {
- fsl,pins = <
- VF610_PAD_PTB10__UART0_TX 0x21a2
- VF610_PAD_PTB11__UART0_RX 0x21a1
- >;
- };
-
- pinctrl_uart1: uart1grp {
- fsl,pins = <
- VF610_PAD_PTB23__UART1_TX 0x21a2
- VF610_PAD_PTB24__UART1_RX 0x21a1
- >;
- };
-
- pinctrl_uart2: uart2grp {
- fsl,pins = <
- VF610_PAD_PTD0__UART2_TX 0x21a2
- VF610_PAD_PTD1__UART2_RX 0x21a1
- >;
- };
-
- pinctrl_usb_vbus: pinctrl-usb-vbus {
- fsl,pins = <
- VF610_PAD_PTA16__GPIO_6 0x31c2
- >;
- };
-
- pinctrl_usb0_host: usb0-host-grp {
- fsl,pins = <
- VF610_PAD_PTD6__GPIO_85 0x0062
- >;
- };
};
diff --git a/arch/arm/boot/dts/vf610-zii-dev-rev-c.dts b/arch/arm/boot/dts/vf610-zii-dev-rev-c.dts
new file mode 100644
index 0000000..ff17001
--- /dev/null
+++ b/arch/arm/boot/dts/vf610-zii-dev-rev-c.dts
@@ -0,0 +1,394 @@
+/*
+ * Copyright (C) 2015, 2016 Zodiac Inflight Innovations
+ *
+ * Based on an original 'vf610-twr.dts' which is Copyright 2015,
+ * Freescale Semiconductor, Inc.
+ *
+ * This file is dual-licensed: you can use it either under the terms
+ * of the GPL or the X11 license, at your option. Note that this dual
+ * licensing only applies to this file, and not this project as a
+ * whole.
+ *
+ * a) This file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This file is distributed in the hope that it will be useful
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * Or, alternatively
+ *
+ * b) Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use
+ * copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED , WITHOUT WARRANTY OF ANY KIND
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/dts-v1/;
+#include "vf610-zii-dev.dtsi"
+
+/ {
+ model = "ZII VF610 Development Board, Rev C";
+ compatible = "zii,vf610dev-c", "zii,vf610dev", "fsl,vf610";
+
+ mdio-mux {
+ compatible = "mdio-mux-gpio";
+ pinctrl-0 = <&pinctrl_mdio_mux>;
+ pinctrl-names = "default";
+ gpios = <&gpio0 8 GPIO_ACTIVE_HIGH
+ &gpio0 9 GPIO_ACTIVE_HIGH
+ &gpio0 25 GPIO_ACTIVE_HIGH>;
+ mdio-parent-bus = <&mdio1>;
+ #address-cells = <1>;
+ #size-cells = <0>;
+
+ mdio_mux_1: mdio@1 {
+ reg = <1>;
+ #address-cells = <1>;
+ #size-cells = <0>;
+
+ switch0: switch0@0 {
+ compatible = "marvell,mv88e6190";
+ #address-cells = <1>;
+ #size-cells = <0>;
+ reg = <0>;
+ dsa,member = <0 0>;
+
+ ports {
+ #address-cells = <1>;
+ #size-cells = <0>;
+
+ port@0 {
+ reg = <0>;
+ label = "cpu";
+ ethernet = <&fec1>;
+ fixed-link {
+ speed = <100>;
+ full-duplex;
+ };
+ };
+
+ port@1 {
+ reg = <1>;
+ label = "lan1";
+ };
+
+ port@2 {
+ reg = <2>;
+ label = "lan2";
+ };
+
+ port@3 {
+ reg = <3>;
+ label = "lan3";
+ };
+
+ port@4 {
+ reg = <4>;
+ label = "lan4";
+ };
+
+ switch0port10: port@10 {
+ reg = <10>;
+ label = "dsa";
+ phy-mode = "xgmii";
+ link = <&switch1port10>;
+ };
+ };
+ };
+ };
+
+ mdio_mux_2: mdio@2 {
+ reg = <2>;
+ #address-cells = <1>;
+ #size-cells = <0>;
+
+ switch1: switch1@0 {
+ compatible = "marvell,mv88e6190";
+ #address-cells = <1>;
+ #size-cells = <0>;
+ reg = <0>;
+ dsa,member = <0 1>;
+
+ ports {
+ #address-cells = <1>;
+ #size-cells = <0>;
+
+ port@1 {
+ reg = <1>;
+ label = "lan5";
+ };
+
+ port@2 {
+ reg = <2>;
+ label = "lan6";
+ };
+
+ port@3 {
+ reg = <3>;
+ label = "lan7";
+ };
+
+ port@4 {
+ reg = <4>;
+ label = "lan8";
+ };
+
+
+ switch1port10: port@10 {
+ reg = <10>;
+ label = "dsa";
+ phy-mode = "xgmii";
+ link = <&switch0port10>;
+ };
+ };
+ };
+ };
+
+ mdio_mux_4: mdio@4 {
+ reg = <4>;
+ #address-cells = <1>;
+ #size-cells = <0>;
+ };
+ };
+};
+
+&dspi0 {
+ bus-num = <0>;
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_dspi0>;
+ status = "okay";
+ spi-num-chipselects = <2>;
+
+ m25p128@0 {
+ compatible = "m25p128", "jedec,spi-nor";
+ #address-cells = <1>;
+ #size-cells = <1>;
+ reg = <0>;
+ spi-max-frequency = <1000000>;
+ };
+};
+
+&i2c0 {
+ /*
+ * U712
+ *
+ * Exposed signals:
+ * P1 - WE2_CMD
+ * P2 - WE2_CLK
+ */
+ gpio5: pca9557@18 {
+ compatible = "nxp,pca9557";
+ reg = <0x18>;
+ gpio-controller;
+ #gpio-cells = <2>;
+ };
+
+ /*
+ * U121
+ *
+ * Exposed signals:
+ * I/O0 - ENET_SWR_EN
+ * I/O1 - ESW1_RESETn
+ * I/O2 - ARINC_RESET
+ * I/O3 - DD1_IO_RESET
+ * I/O4 - ESW2_RESETn
+ * I/O5 - ESW3_RESETn
+ * I/O6 - ESW4_RESETn
+ * I/O8 - TP909
+ * I/O9 - FEM_SEL
+ * I/O10 - WIFI_RESETn
+ * I/O11 - PHY_RSTn
+ * I/O12 - OPT1_SD
+ * I/O13 - OPT2_SD
+ * I/O14 - OPT1_TX_DIS
+ * I/O15 - OPT2_TX_DIS
+ */
+ gpio6: sx1503@20 {
+ compatible = "semtech,sx1503q";
+
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_sx1503_20>;
+ #gpio-cells = <2>;
+ #interrupt-cells = <2>;
+ reg = <0x20>;
+ interrupt-parent = <&gpio0>;
+ interrupts = <23 IRQ_TYPE_EDGE_FALLING>;
+ gpio-controller;
+ interrupt-controller;
+
+ enet_swr_en {
+ gpio-hog;
+ gpios = <0 GPIO_ACTIVE_HIGH>;
+ output-high;
+ line-name = "enet-swr-en";
+ };
+ };
+
+ /*
+ * U715
+ *
+ * Exposed signals:
+ * IO0 - WE1_CLK
+ * IO1 - WE1_CMD
+ */
+ gpio7: pca9554@22 {
+ compatible = "nxp,pca9554";
+ reg = <0x22>;
+ gpio-controller;
+ #gpio-cells = <2>;
+
+ };
+};
+
+&i2c1 {
+ at24mac602@00 {
+ compatible = "atmel,24c02";
+ reg = <0x50>;
+ read-only;
+ };
+};
+
+&i2c2 {
+ tca9548@70 {
+ compatible = "nxp,pca9548";
+ pinctrl-0 = <&pinctrl_i2c_mux_reset>;
+ pinctrl-names = "default";
+ #address-cells = <1>;
+ #size-cells = <0>;
+ reg = <0x70>;
+ reset-gpios = <&gpio3 23 GPIO_ACTIVE_LOW>;
+
+ i2c@0 {
+ #address-cells = <1>;
+ #size-cells = <0>;
+ reg = <0>;
+ };
+
+ i2c@1 {
+ #address-cells = <1>;
+ #size-cells = <0>;
+ reg = <1>;
+
+ sfp2: at24c04@50 {
+ compatible = "atmel,24c02";
+ reg = <0x50>;
+ };
+ };
+
+ i2c@2 {
+ #address-cells = <1>;
+ #size-cells = <0>;
+ reg = <2>;
+
+ sfp3: at24c04@50 {
+ compatible = "atmel,24c02";
+ reg = <0x50>;
+ };
+ };
+
+ i2c@3 {
+ #address-cells = <1>;
+ #size-cells = <0>;
+ reg = <3>;
+ };
+ };
+};
+
+&uart3 {
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_uart3>;
+ status = "okay";
+};
+
+&gpio0 {
+ eth0_intrp {
+ gpio-hog;
+ gpios = <23 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "sx1503-irq";
+ };
+};
+
+&gpio3 {
+ eth0_intrp {
+ gpio-hog;
+ gpios = <2 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "eth0-intrp";
+ };
+};
+
+&fec0 {
+ mdio {
+ #address-cells = <1>;
+ #size-cells = <0>;
+ status = "okay";
+
+ ethernet-phy@0 {
+ compatible = "ethernet-phy-id0022.1550", "ethernet-phy-ieee802.3-c22";
+
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_fec0_phy_int>;
+
+ interrupt-parent = <&gpio3>;
+ interrupts = <2 IRQ_TYPE_EDGE_FALLING>;
+ reg = <0>;
+ };
+ };
+};
+
+&iomuxc {
+ pinctr_atzb_rf_233: pinctrl-atzb-rf-233 {
+ fsl,pins = <
+ VF610_PAD_PTB2__GPIO_24 0x31c2
+ VF610_PAD_PTE27__GPIO_132 0x33e2
+ >;
+ };
+
+
+ pinctrl_sx1503_20: pinctrl-sx1503-20 {
+ fsl,pins = <
+ VF610_PAD_PTB1__GPIO_23 0x219d
+ >;
+ };
+
+ pinctrl_uart3: uart3grp {
+ fsl,pins = <
+ VF610_PAD_PTA20__UART3_TX 0x21a2
+ VF610_PAD_PTA21__UART3_RX 0x21a1
+ >;
+ };
+
+ pinctrl_mdio_mux: pinctrl-mdio-mux {
+ fsl,pins = <
+ VF610_PAD_PTA18__GPIO_8 0x31c2
+ VF610_PAD_PTA19__GPIO_9 0x31c2
+ VF610_PAD_PTB3__GPIO_25 0x31c2
+ >;
+ };
+
+ pinctrl_fec0_phy_int: pinctrl-fec0-phy-int {
+ fsl,pins = <
+ VF610_PAD_PTB28__GPIO_98 0x2181
+ >;
+ };
+};
diff --git a/arch/arm/boot/dts/vf610-zii-dev.dtsi b/arch/arm/boot/dts/vf610-zii-dev.dtsi
new file mode 100644
index 0000000..9f5e2e7
--- /dev/null
+++ b/arch/arm/boot/dts/vf610-zii-dev.dtsi
@@ -0,0 +1,383 @@
+/*
+ * Copyright (C) 2015, 2016 Zodiac Inflight Innovations
+ *
+ * Based on an original 'vf610-twr.dts' which is Copyright 2015,
+ * Freescale Semiconductor, Inc.
+ *
+ * This file is dual-licensed: you can use it either under the terms
+ * of the GPL or the X11 license, at your option. Note that this dual
+ * licensing only applies to this file, and not this project as a
+ * whole.
+ *
+ * a) This file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This file is distributed in the hope that it will be useful
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * Or, alternatively
+ *
+ * b) Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use
+n * copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED , WITHOUT WARRANTY OF ANY KIND
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "vf610.dtsi"
+
+/ {
+ chosen {
+ stdout-path = "serial0:115200n8";
+ };
+
+ memory {
+ reg = <0x80000000 0x20000000>;
+ };
+
+ gpio-leds {
+ compatible = "gpio-leds";
+ pinctrl-0 = <&pinctrl_leds_debug>;
+ pinctrl-names = "default";
+
+ debug {
+ label = "zii:green:debug1";
+ gpios = <&gpio2 10 GPIO_ACTIVE_HIGH>;
+ linux,default-trigger = "heartbeat";
+ };
+ };
+
+ reg_vcc_3v3_mcu: regulator-vcc-3v3-mcu {
+ compatible = "regulator-fixed";
+ regulator-name = "vcc_3v3_mcu";
+ regulator-min-microvolt = <3300000>;
+ regulator-max-microvolt = <3300000>;
+ };
+
+ usb0_vbus: regulator-usb0-vbus {
+ compatible = "regulator-fixed";
+ pinctrl-0 = <&pinctrl_usb_vbus>;
+ regulator-name = "usb_vbus";
+ regulator-min-microvolt = <5000000>;
+ regulator-max-microvolt = <5000000>;
+ enable-active-high;
+ regulator-always-on;
+ regulator-boot-on;
+ gpio = <&gpio0 6 0>;
+ };
+};
+
+&adc0 {
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_adc0_ad5>;
+ vref-supply = <®_vcc_3v3_mcu>;
+ status = "okay";
+};
+
+&edma0 {
+ status = "okay";
+};
+
+&esdhc1 {
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_esdhc1>;
+ bus-width = <4>;
+ status = "okay";
+};
+
+&fec0 {
+ phy-mode = "rmii";
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_fec0>;
+ status = "okay";
+};
+
+&fec1 {
+ phy-mode = "rmii";
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_fec1>;
+ status = "okay";
+
+ fixed-link {
+ speed = <100>;
+ full-duplex;
+ };
+
+ mdio1: mdio {
+ #address-cells = <1>;
+ #size-cells = <0>;
+ status = "okay";
+ };
+};
+
+&i2c0 {
+ clock-frequency = <100000>;
+ pinctrl-names = "default", "gpio";
+ pinctrl-0 = <&pinctrl_i2c0>;
+ pinctrl-1 = <&pinctrl_i2c0_gpio>;
+ scl-gpios = <&gpio1 4 GPIO_ACTIVE_HIGH>;
+ sda-gpios = <&gpio1 5 GPIO_ACTIVE_HIGH>;
+ status = "okay";
+
+ lm75@48 {
+ compatible = "national,lm75";
+ reg = <0x48>;
+ };
+
+ at24c04@50 {
+ compatible = "atmel,24c04";
+ reg = <0x50>;
+ };
+
+ at24c04@52 {
+ compatible = "atmel,24c04";
+ reg = <0x52>;
+ };
+
+ ds1682@6b {
+ compatible = "dallas,ds1682";
+ reg = <0x6b>;
+ };
+};
+
+&i2c1 {
+ clock-frequency = <100000>;
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_i2c1>;
+ status = "okay";
+};
+
+&i2c2 {
+ clock-frequency = <100000>;
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_i2c2>;
+ status = "okay";
+};
+
+&uart0 {
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_uart0>;
+ status = "okay";
+};
+
+&uart1 {
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_uart1>;
+ status = "okay";
+};
+
+&uart2 {
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_uart2>;
+ status = "okay";
+};
+
+&usbdev0 {
+ disable-over-current;
+ vbus-supply = <&usb0_vbus>;
+ dr_mode = "host";
+ status = "okay";
+};
+
+&usbh1 {
+ disable-over-current;
+ status = "okay";
+};
+
+&usbmisc0 {
+ status = "okay";
+};
+
+&usbmisc1 {
+ status = "okay";
+};
+
+&usbphy0 {
+ status = "okay";
+};
+
+&usbphy1 {
+ status = "okay";
+};
+
+&iomuxc {
+ pinctrl_adc0_ad5: adc0ad5grp {
+ fsl,pins = <
+ VF610_PAD_PTC30__ADC0_SE5 0x00a1
+ >;
+ };
+
+ pinctrl_dspi0: dspi0grp {
+ fsl,pins = <
+ VF610_PAD_PTB18__DSPI0_CS1 0x1182
+ VF610_PAD_PTB19__DSPI0_CS0 0x1182
+ VF610_PAD_PTB20__DSPI0_SIN 0x1181
+ VF610_PAD_PTB21__DSPI0_SOUT 0x1182
+ VF610_PAD_PTB22__DSPI0_SCK 0x1182
+ >;
+ };
+
+ pinctrl_dspi2: dspi2grp {
+ fsl,pins = <
+ VF610_PAD_PTD31__DSPI2_CS1 0x1182
+ VF610_PAD_PTD30__DSPI2_CS0 0x1182
+ VF610_PAD_PTD29__DSPI2_SIN 0x1181
+ VF610_PAD_PTD28__DSPI2_SOUT 0x1182
+ VF610_PAD_PTD27__DSPI2_SCK 0x1182
+ >;
+ };
+
+ pinctrl_esdhc1: esdhc1grp {
+ fsl,pins = <
+ VF610_PAD_PTA24__ESDHC1_CLK 0x31ef
+ VF610_PAD_PTA25__ESDHC1_CMD 0x31ef
+ VF610_PAD_PTA26__ESDHC1_DAT0 0x31ef
+ VF610_PAD_PTA27__ESDHC1_DAT1 0x31ef
+ VF610_PAD_PTA28__ESDHC1_DATA2 0x31ef
+ VF610_PAD_PTA29__ESDHC1_DAT3 0x31ef
+ VF610_PAD_PTA7__GPIO_134 0x219d
+ >;
+ };
+
+ pinctrl_fec0: fec0grp {
+ fsl,pins = <
+ VF610_PAD_PTC0__ENET_RMII0_MDC 0x30d2
+ VF610_PAD_PTC1__ENET_RMII0_MDIO 0x30d3
+ VF610_PAD_PTC2__ENET_RMII0_CRS 0x30d1
+ VF610_PAD_PTC3__ENET_RMII0_RXD1 0x30d1
+ VF610_PAD_PTC4__ENET_RMII0_RXD0 0x30d1
+ VF610_PAD_PTC5__ENET_RMII0_RXER 0x30d1
+ VF610_PAD_PTC6__ENET_RMII0_TXD1 0x30d2
+ VF610_PAD_PTC7__ENET_RMII0_TXD0 0x30d2
+ VF610_PAD_PTC8__ENET_RMII0_TXEN 0x30d2
+ >;
+ };
+
+ pinctrl_fec1: fec1grp {
+ fsl,pins = <
+ VF610_PAD_PTA6__RMII_CLKIN 0x30d1
+ VF610_PAD_PTC9__ENET_RMII1_MDC 0x30d2
+ VF610_PAD_PTC10__ENET_RMII1_MDIO 0x30d3
+ VF610_PAD_PTC11__ENET_RMII1_CRS 0x30d1
+ VF610_PAD_PTC12__ENET_RMII1_RXD1 0x30d1
+ VF610_PAD_PTC13__ENET_RMII1_RXD0 0x30d1
+ VF610_PAD_PTC14__ENET_RMII1_RXER 0x30d1
+ VF610_PAD_PTC15__ENET_RMII1_TXD1 0x30d2
+ VF610_PAD_PTC16__ENET_RMII1_TXD0 0x30d2
+ VF610_PAD_PTC17__ENET_RMII1_TXEN 0x30d2
+ >;
+ };
+
+ pinctrl_gpio_spi0: pinctrl-gpio-spi0 {
+ fsl,pins = <
+ VF610_PAD_PTB22__GPIO_44 0x33e2
+ VF610_PAD_PTB21__GPIO_43 0x33e2
+ VF610_PAD_PTB20__GPIO_42 0x33e1
+ VF610_PAD_PTB19__GPIO_41 0x33e2
+ VF610_PAD_PTB18__GPIO_40 0x33e2
+ >;
+ };
+
+ pinctrl_i2c_mux_reset: pinctrl-i2c-mux-reset {
+ fsl,pins = <
+ VF610_PAD_PTE14__GPIO_119 0x31c2
+ >;
+ };
+
+ pinctrl_i2c0: i2c0grp {
+ fsl,pins = <
+ VF610_PAD_PTB14__I2C0_SCL 0x37ff
+ VF610_PAD_PTB15__I2C0_SDA 0x37ff
+ >;
+ };
+
+ pinctrl_i2c0_gpio: i2c0grp-gpio {
+ fsl,pins = <
+ VF610_PAD_PTB14__GPIO_36 0x31c2
+ VF610_PAD_PTB15__GPIO_37 0x31c2
+ >;
+ };
+
+
+ pinctrl_i2c1: i2c1grp {
+ fsl,pins = <
+ VF610_PAD_PTB16__I2C1_SCL 0x37ff
+ VF610_PAD_PTB17__I2C1_SDA 0x37ff
+ >;
+ };
+
+ pinctrl_i2c2: i2c2grp {
+ fsl,pins = <
+ VF610_PAD_PTA22__I2C2_SCL 0x37ff
+ VF610_PAD_PTA23__I2C2_SDA 0x37ff
+ >;
+ };
+
+ pinctrl_leds_debug: pinctrl-leds-debug {
+ fsl,pins = <
+ VF610_PAD_PTD20__GPIO_74 0x31c2
+ >;
+ };
+
+ pinctrl_qspi0: qspi0grp {
+ fsl,pins = <
+ VF610_PAD_PTD7__QSPI0_B_QSCK 0x31c3
+ VF610_PAD_PTD8__QSPI0_B_CS0 0x31ff
+ VF610_PAD_PTD9__QSPI0_B_DATA3 0x31c3
+ VF610_PAD_PTD10__QSPI0_B_DATA2 0x31c3
+ VF610_PAD_PTD11__QSPI0_B_DATA1 0x31c3
+ VF610_PAD_PTD12__QSPI0_B_DATA0 0x31c3
+ >;
+ };
+
+ pinctrl_uart0: uart0grp {
+ fsl,pins = <
+ VF610_PAD_PTB10__UART0_TX 0x21a2
+ VF610_PAD_PTB11__UART0_RX 0x21a1
+ >;
+ };
+
+ pinctrl_uart1: uart1grp {
+ fsl,pins = <
+ VF610_PAD_PTB23__UART1_TX 0x21a2
+ VF610_PAD_PTB24__UART1_RX 0x21a1
+ >;
+ };
+
+ pinctrl_uart2: uart2grp {
+ fsl,pins = <
+ VF610_PAD_PTD0__UART2_TX 0x21a2
+ VF610_PAD_PTD1__UART2_RX 0x21a1
+ >;
+ };
+
+ pinctrl_usb_vbus: pinctrl-usb-vbus {
+ fsl,pins = <
+ VF610_PAD_PTA16__GPIO_6 0x31c2
+ >;
+ };
+
+ pinctrl_usb0_host: usb0-host-grp {
+ fsl,pins = <
+ VF610_PAD_PTD6__GPIO_85 0x0062
+ >;
+ };
+};
--
2.5.5
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply related
* [PATCH v2 1/3] ARM: dts: vf610-zii-dev-rev-b: Remove leftover PWM pingroup
From: Andrey Smirnov @ 2016-12-03 22:30 UTC (permalink / raw)
To: linux-arm-kernel
Cc: Andrey Smirnov, Shawn Guo, Rob Herring, Mark Rutland,
Russell King, Sascha Hauer, Stefan Agner, devicetree,
linux-kernel, andrew, cphealy
Remove pwm0grp since it is:
a) Not referenced anywhere in the DTS file (unlike Tower board it
is based on, this board does not use/expose FTM0)
b) Configures PTB2 and PTB3 in a way that contradicts
pinctrl-mdio-mux
Signed-off-by: Andrey Smirnov <andrew.smirnov@gmail.com>
---
No changes since v1
arch/arm/boot/dts/vf610-zii-dev-rev-b.dts | 9 ---------
1 file changed, 9 deletions(-)
diff --git a/arch/arm/boot/dts/vf610-zii-dev-rev-b.dts b/arch/arm/boot/dts/vf610-zii-dev-rev-b.dts
index fa19cfd..2210811 100644
--- a/arch/arm/boot/dts/vf610-zii-dev-rev-b.dts
+++ b/arch/arm/boot/dts/vf610-zii-dev-rev-b.dts
@@ -677,15 +677,6 @@
>;
};
- pinctrl_pwm0: pwm0grp {
- fsl,pins = <
- VF610_PAD_PTB0__FTM0_CH0 0x1582
- VF610_PAD_PTB1__FTM0_CH1 0x1582
- VF610_PAD_PTB2__FTM0_CH2 0x1582
- VF610_PAD_PTB3__FTM0_CH3 0x1582
- >;
- };
-
pinctrl_qspi0: qspi0grp {
fsl,pins = <
VF610_PAD_PTD7__QSPI0_B_QSCK 0x31c3
--
2.5.5
^ permalink raw reply related
* Re: [PATCH 39/39] mtd: nand: denali_dt: add compatible strings for UniPhier SoC variants
From: Dinh Nguyen @ 2016-12-03 22:08 UTC (permalink / raw)
To: Marek Vasut
Cc: Masahiro Yamada, Rob Herring, linux-mtd@lists.infradead.org,
devicetree@vger.kernel.org, Linux Kernel Mailing List,
Boris Brezillon, Brian Norris, Richard Weinberger,
David Woodhouse, Cyrille Pitchen, Mark Rutland, Dinh Nguyen,
Alan Tull, Chin Liang See, Dinh Nguyen
In-Reply-To: <f98b49b9-91fc-c3d0-1ace-fa862581e53b@gmail.com>
Hi,
On Fri, Dec 2, 2016 at 8:49 PM, Marek Vasut <marek.vasut@gmail.com> wrote:
> On 12/03/2016 03:41 AM, Masahiro Yamada wrote:
>> Hi Rob,
>
> Hi!
>
>> 2016-12-03 1:26 GMT+09:00 Rob Herring <robh@kernel.org>:
>>
>>>>
>>>>
>>>> (Plan A)
>>>> "denali,socfpga-nand" (for Altera SOCFPGA variant)
>>>> "denali,uniphier-nand-v1" (for old Socionext UniPhier family variant)
>>>> "denali,uniphier-nand-v2" (for new Socionext UniPhier family variant)
>>>>
>>>> (Plan B)
>>>> "altera,denali-nand" (for Altera SOCFPGA variant)
>>>> "socionext,denali-nand-v5a" (for old Socionext UniPhier family variant)
>>>> "socionext,denali-nand-v5b" (for new Socionext UniPhier family variant)
>>
>>> Let the Altera folks worry about their stuff. At least for soft IP in
>>> FPGA, it's a bit of a special case. The old string can remain as bad
>>> as it is.
>>
>>
>> Hmm, I am not sure if this IP would fit in FPGA
>> (to use it along with NIOS-II?)
>>
>> (even if it happened, nothing of this IP would be customizable on users' side.
>> When buying the IP, SoC vendors submit a list of desired features.
>> Denali (now Cadence) generates the RTL according to the configuration sheet.
>> The function is fixed at this point. So, generic compatible would be
>> useless anyway.)
>>
>>
>> If we are talking about SOCFPGA,
>> SOCFPGA is not only FPGA. Rather "SOC" + "FPGA".
>> It consists of two parts:
>> [1] SOC part (Cortex-A9 + various hard-wired peripherals such UART,
>> USB, SD, NAND, ...)
>> [2] FPGA part (User design logic)
>>
>> The Denali NAND controller is included in [1].
>> So, as far as we talk about the Denali on SOCFPGA,
>> it is as hard-wired as Intel, Socionext's ones.
>
> That's correct, the Denali NAND IP in altera socfpga is a hardware
> block. You can make it available to the fabric too, but by default
> it's used by the ARM part of the chip, so for this discussion, you
> can forget that the FPGA part exists altogether.
>
> I would be in favor of plan B, since it seems to be the more often
> taken approach. A nice example is ci-hdrc:
>
> $ git grep compatible drivers/usb/chipidea/
>
>>> I simply would do "socionext,uniphier-v5b-nand" (and v5a).
>>> The fact that it is denali is part of the documentation.
>>>
>>
>> Let me think about this.
>>
>> Socionext bought two version of Denali IP,
>> and we are now re-using the newer one (v5b) for several SoCs.
>> Socionext has some more product lines other than Uniphier SoC family,
>> perhaps wider re-use might happen in the future.
>>
>> At first, I included "uniphier" in compatible, but I am still wondering
>> if such a specific string is good or not.
>>
>> Also, comments from Altera engineers are appreciated.
Sorry, it's taken me a while to add comments. My altera email is very spotty now
that the Intel merge is completed. Please use dinguyen@kernel.org for any future
communications.
Yes, everything that is said so far for the NAND controller on the
SoCFPGA is correct. I added the binding for the controller a while
back, but unfortunately, we never added the NAND interface to the
devkit, so we did not do much in terms of enabling it.
I think the only SoCFPGA board I know that has the NAND interface active is
the TRCom board, but I have never seen that board.
I don't have any strong opinions on this matter, just as long as the
original binding
"denali,denali-nand-dt" is kept, and I think Rob was ok with keeping
that binding.
Dinh
^ permalink raw reply
* Re: [RFC PATCH 2/2] Documentation: devictree: Add macb mdio bindings
From: Rob Herring @ 2016-12-03 21:35 UTC (permalink / raw)
To: Harini Katakam
Cc: nicolas.ferre-AIFe0yeh4nAAvxtiuMwx3w,
davem-fT/PcQaiUtIeIZ0/mPfg9Q, pawel.moll-5wv7dgnIgG8,
mark.rutland-5wv7dgnIgG8, ijc+devicetree-KcIKpvwj1kUDXYZnReoRVg,
galak-sgV2jX0FEOL9JmXXK+q4OQ,
boris.brezillon-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8,
alexandre.belloni-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8,
harinikatakamlinux-Re5JQEeQqe8AvxtiuMwx3w,
netdev-u79uwXL29TY76Z2rM5mHXA,
linux-kernel-u79uwXL29TY76Z2rM5mHXA,
devicetree-u79uwXL29TY76Z2rM5mHXA, harinik-gjFFaj9aHVfQT0dZR+AlfA,
michals-gjFFaj9aHVfQT0dZR+AlfA
In-Reply-To: <1480326567-6132-1-git-send-email-harinik-gjFFaj9aHVfQT0dZR+AlfA@public.gmane.org>
On Mon, Nov 28, 2016 at 03:19:27PM +0530, Harini Katakam wrote:
> Add documentations for macb mdio driver.
Bindings document h/w, not drivers.
>
> Signed-off-by: Harini Katakam <harinik-gjFFaj9aHVfQT0dZR+AlfA@public.gmane.org>
> ---
> .../devicetree/bindings/net/macb-mdio.txt | 31 ++++++++++++++++++++++
> 1 file changed, 31 insertions(+)
> create mode 100644 Documentation/devicetree/bindings/net/macb-mdio.txt
>
> diff --git a/Documentation/devicetree/bindings/net/macb-mdio.txt b/Documentation/devicetree/bindings/net/macb-mdio.txt
> new file mode 100644
> index 0000000..014cedf
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/net/macb-mdio.txt
> @@ -0,0 +1,31 @@
> +* Cadence MACB MDIO controller
> +
> +Required properties:
> +- compatible: Should be "cdns,macb-mdio"
Only one version ever? This needs more specific compatible strings.
> +- reg: Address and length of the register set of MAC to be used
> +- clock-names: Tuple listing input clock names.
> + Required elements: 'pclk', 'hclk'
> + Optional elements: 'tx_clk'
> +- clocks: Phandles to input clocks.
> +
> +Examples:
> +
> + mdio {
> + compatible = "cdns,macb-mdio";
> + reg = <0x0 0xff0b0000 0x0 0x1000>;
> + clocks = <&clk125>, <&clk125>, <&clk125>;
> + clock-names = "pclk", "hclk", "tx_clk";
> + ethernet_phyC: ethernet-phy@C {
lowercase hex for unit addresses please
> + reg = <0xC>;
> + };
> + ethernet_phy7: ethernet-phy@7 {
> + reg = <0x7>;
> + };
> + ethernet_phy3: ethernet-phy@3 {
> + reg = <0x3>;
> + };
> + ethernet_phy8: ethernet-phy@8 {
> + reg = <0x8>;
> + };
> + };
> +
> --
> 2.7.4
>
> --
> To unsubscribe from this list: send the line "unsubscribe devicetree" in
> the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [PATCH 1/3][v2] dt-bindings: Add compatible for LS2088A QDS and RDB boards
From: Rob Herring @ 2016-12-03 21:33 UTC (permalink / raw)
To: Abhimanyu Saini
Cc: devicetree-u79uwXL29TY76Z2rM5mHXA, mark.rutland-5wv7dgnIgG8,
shawnguo-DgEjT+Ai2ygdnm+yROfE0A, scott.wood-3arQi8VN3Tc,
stuart.yoder-3arQi8VN3Tc,
linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r, Priyanka Jain,
Ashish Kumar
In-Reply-To: <1480325824-14649-2-git-send-email-abhimanyu.saini-3arQi8VN3Tc@public.gmane.org>
On Mon, Nov 28, 2016 at 03:07:02PM +0530, Abhimanyu Saini wrote:
> Signed-off-by: Abhimanyu Saini <abhimanyu.saini-3arQi8VN3Tc@public.gmane.org>
> Signed-off-by: Priyanka Jain <priyanka.jain-3arQi8VN3Tc@public.gmane.org>
> Signed-off-by: Ashish Kumar <ashish.kumar-3arQi8VN3Tc@public.gmane.org>
> ---
> Documentation/devicetree/bindings/arm/fsl.txt | 11 +++++++++++
> 1 file changed, 11 insertions(+)
Acked-by: Rob Herring <robh-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org>
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [PATCH] dt-bindings: add MYIR Tech hardware vendor prefix
From: Rob Herring @ 2016-12-03 21:32 UTC (permalink / raw)
To: Vladimir Zapolskiy
Cc: Mark Rutland, devicetree-u79uwXL29TY76Z2rM5mHXA,
linux-kernel-u79uwXL29TY76Z2rM5mHXA
In-Reply-To: <20161128075651.11620-1-vz-ChpfBGZJDbMAvxtiuMwx3w@public.gmane.org>
On Mon, Nov 28, 2016 at 09:56:51AM +0200, Vladimir Zapolskiy wrote:
> MYIR Tech Limited offers a range of ARM powered development boards and SoMs,
> for details reference a list on http://elinux.org/Development_Platforms#ARM
> or company's website http://myirtech.com
>
> Signed-off-by: Vladimir Zapolskiy <vz-ChpfBGZJDbMAvxtiuMwx3w@public.gmane.org>
> ---
> Documentation/devicetree/bindings/vendor-prefixes.txt | 1 +
> 1 file changed, 1 insertion(+)
Applied, thanks.
Rob
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [PATCH v2] rtc: add support for EPSON TOYOCOM RTC-7301SF/DG
From: Alexandre Belloni @ 2016-12-03 21:14 UTC (permalink / raw)
To: Akinobu Mita
Cc: rtc-linux-/JYPxA39Uh5TLH3MbocFFw,
devicetree-u79uwXL29TY76Z2rM5mHXA, Alessandro Zummo
In-Reply-To: <1480781636-15653-1-git-send-email-akinobu.mita-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>
Hi,
On 04/12/2016 at 01:13:56 +0900, Akinobu Mita wrote :
> diff --git a/drivers/rtc/rtc-r7301.c b/drivers/rtc/rtc-r7301.c
> new file mode 100644
> index 0000000..0929f10
> --- /dev/null
> +++ b/drivers/rtc/rtc-r7301.c
> @@ -0,0 +1,455 @@
> +/*
> + * EPSON TOYOCOM RTC-7301SF/DG Driver
> + *
> + * Copyright (c) 2016 Akinobu Mita <akinobu.mita-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>
> + *
> + * Based on rtc-rp5c01.c
> + *
> + * Datasheet: http://www5.epsondevice.com/en/products/parallel/rtc7301sf.html
> + */
> +
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/delay.h>
> +#include <linux/regmap.h>
> +#include <linux/platform_device.h>
> +#include <linux/rtc.h>
> +
> +#define DRV_NAME "rtc-r7301"
> +
> +enum {
> + RTC7301_1_SEC = 0x0, /* Bank 0 and Band 1 */
> + RTC7301_10_SEC = 0x1, /* Bank 0 and Band 1 */
> + RTC7301_AE = BIT(3),
> + RTC7301_1_MIN = 0x2, /* Bank 0 and Band 1 */
> + RTC7301_10_MIN = 0x3, /* Bank 0 and Band 1 */
> + RTC7301_1_HOUR = 0x4, /* Bank 0 and Band 1 */
> + RTC7301_10_HOUR = 0x5, /* Bank 0 and Band 1 */
> + RTC7301_DAY_OF_WEEK = 0x6, /* Bank 0 and Band 1 */
> + RTC7301_1_DAY = 0x7, /* Bank 0 and Band 1 */
> + RTC7301_10_DAY = 0x8, /* Bank 0 and Band 1 */
> + RTC7301_1_MONTH = 0x9, /* Bank 0 */
> + RTC7301_10_MONTH = 0xa, /* Bank 0 */
> + RTC7301_1_YEAR = 0xb, /* Bank 0 */
> + RTC7301_10_YEAR = 0xc, /* Bank 0 */
> + RTC7301_100_YEAR = 0xd, /* Bank 0 */
> + RTC7301_1000_YEAR = 0xe, /* Bank 0 */
> + RTC7301_ALARM_CONTROL = 0xe, /* Bank 1 */
> + RTC7301_ALARM_CONTROL_AIE = BIT(0),
> + RTC7301_ALARM_CONTROL_AF = BIT(1),
> + RTC7301_TIMER_CONTROL = 0xe, /* Bank 2 */
> + RTC7301_TIMER_CONTROL_TIE = BIT(0),
> + RTC7301_TIMER_CONTROL_TF = BIT(1),
> + RTC7301_CONTROL = 0xf, /* All banks */
> + RTC7301_CONTROL_BUSY = BIT(0),
> + RTC7301_CONTROL_STOP = BIT(1),
> + RTC7301_CONTROL_BANK_SEL_0 = BIT(2),
> + RTC7301_CONTROL_BANK_SEL_1 = BIT(3),
> +};
> +
Well, I'm still not convinced this enum is useful, please change those
to #defines.
Else, this seems good to me.
--
Alexandre Belloni, Free Electrons
Embedded Linux and Kernel engineering
http://free-electrons.com
--
You received this message because you are subscribed to "rtc-linux".
Membership options at http://groups.google.com/group/rtc-linux .
Please read http://groups.google.com/group/rtc-linux/web/checklist
before submitting a driver.
---
You received this message because you are subscribed to the Google Groups "rtc-linux" group.
To unsubscribe from this group and stop receiving emails from it, send an email to rtc-linux+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/Ez6ZCGd0@public.gmane.org
For more options, visit https://groups.google.com/d/optout.
^ permalink raw reply
* Re: Question regarding clocks in the DW-HDMI DT bindings
From: Vladimir Zapolskiy @ 2016-12-03 21:10 UTC (permalink / raw)
To: Laurent Pinchart, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW
Cc: Fabio Estevam, devicetree-u79uwXL29TY76Z2rM5mHXA@public.gmane.org,
Mike Turquette, Stephen Boyd, nickey.yang-TNX95d0MmH7DzftRWevZcw,
Andy Yan
In-Reply-To: <43555864.BsLMpzJGof@avalon>
Hi Laurent,
On 12/03/2016 07:16 PM, Laurent Pinchart wrote:
> Hi Fabio,
>
> On Friday 25 Nov 2016 13:29:37 Fabio Estevam wrote:
>> On Fri, Nov 25, 2016 at 1:22 PM, Laurent Pinchart wrote:
>>>> I got the clock name from I.MX6Q TRM, I also checked the name again
>>>> with Rockchip IC design team now, hope to get some new information soon.
>>>
>>> Thank you. While at it, could you ask them which version of the DW HDMI IP
>>> used in the SoC ?
>>
>> DW HDMI IP used in Rockchip is:
>> dwhdmi-rockchip ff980000.hdmi: Detected HDMI controller 0x20:0xa:0xa0:0xc1
>>
>> as shown at
>> https://storage.kernelci.org/mainline/v4.9-rc6-157-g16ae16c6e561/arm-multi_
>> v7_defconfig/lab-collabora/boot-rk3288-rock2-square_rootfs:nfs.html
>>
>> DW HDMI IP used on mx6q is:
>> dwhdmi-imx 120000.hdmi: Detected HDMI controller 0x13:0xa:0xa0:0xc1
>
> Would you be able to print the value of the CONFIG[0-3]_ID registers as well ?
> I'm also interested in the same information for RK3288, as well as for IMX6DL.
>
i.MX6Q i.MX6DL
DESIGN_ID 0x13 0x13
REVISION_ID 0x0a 0x1a <--- the only difference
PRODUCT_ID0 0xa0 0xa0
PRODUCT_ID1 0xc1 0xc1
CONFIG0_ID 0x8f 0x8f
CONFIG1_ID 0x01 0x01
CONFIG2_ID 0xf2 0xf2 <--- HDMI 3D TX PHY
CONFIG3_ID 0x02 0x02
I'm not sure, if i.MX6D and MX6S have the same DW HDMI IP as on i.MX6Q
and i.MXDL respectively, and I don't have i.MX6DP or i.MX6QP powered board
on hand to dump the registers.
--
With best wishes,
Vladimir
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: Question regarding clocks in the DW-HDMI DT bindings
From: Laurent Pinchart @ 2016-12-03 17:16 UTC (permalink / raw)
To: dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW
Cc: Fabio Estevam, devicetree-u79uwXL29TY76Z2rM5mHXA@public.gmane.org,
Mike Turquette, Stephen Boyd, nickey.yang-TNX95d0MmH7DzftRWevZcw,
Andy Yan, Vladimir Zapolskiy
In-Reply-To: <CAOMZO5CJTu7jzCb-iVLe2wt8VjyzWq-oYaC2Jw34V8SgaqrGkw-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org>
Hi Fabio,
On Friday 25 Nov 2016 13:29:37 Fabio Estevam wrote:
> On Fri, Nov 25, 2016 at 1:22 PM, Laurent Pinchart wrote:
> >> I got the clock name from I.MX6Q TRM, I also checked the name again
> >> with Rockchip IC design team now, hope to get some new information soon.
> >
> > Thank you. While at it, could you ask them which version of the DW HDMI IP
> > used in the SoC ?
>
> DW HDMI IP used in Rockchip is:
> dwhdmi-rockchip ff980000.hdmi: Detected HDMI controller 0x20:0xa:0xa0:0xc1
>
> as shown at
> https://storage.kernelci.org/mainline/v4.9-rc6-157-g16ae16c6e561/arm-multi_
> v7_defconfig/lab-collabora/boot-rk3288-rock2-square_rootfs:nfs.html
>
> DW HDMI IP used on mx6q is:
> dwhdmi-imx 120000.hdmi: Detected HDMI controller 0x13:0xa:0xa0:0xc1
Would you be able to print the value of the CONFIG[0-3]_ID registers as well ?
I'm also interested in the same information for RK3288, as well as for IMX6DL.
--
Regards,
Laurent Pinchart
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* [PATCH v2] rtc: add support for EPSON TOYOCOM RTC-7301SF/DG
From: Akinobu Mita @ 2016-12-03 16:13 UTC (permalink / raw)
To: rtc-linux-/JYPxA39Uh5TLH3MbocFFw,
devicetree-u79uwXL29TY76Z2rM5mHXA
Cc: Akinobu Mita, Alessandro Zummo, Alexandre Belloni
This adds support for EPSON TOYOCOM RTC-7301SF/DG which has parallel
interface compatible with SRAM.
This driver supports basic clock, calendar and alarm functionality.
Tested with Microblaze linux running on Artix7 FPGA board with my own
custom IP for RTC-7301.
Signed-off-by: Akinobu Mita <akinobu.mita-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>
Acked-by: Rob Herring <robh-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org>
Cc: Alessandro Zummo <a.zummo-BfzFCNDTiLLj+vYz1yj4TQ@public.gmane.org>
Cc: Alexandre Belloni <alexandre.belloni-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8@public.gmane.org>
---
* Changes from v1
- Add interrupt-parent property in the DT example
- Fix typo for RTC7301_TIMER_CONTROL_* register bit field names
- Don't forcibly disable alarm in the initialization
.../devicetree/bindings/rtc/epson,rtc7301.txt | 16 +
drivers/rtc/Kconfig | 11 +
drivers/rtc/Makefile | 1 +
drivers/rtc/rtc-r7301.c | 455 +++++++++++++++++++++
4 files changed, 483 insertions(+)
create mode 100644 Documentation/devicetree/bindings/rtc/epson,rtc7301.txt
create mode 100644 drivers/rtc/rtc-r7301.c
diff --git a/Documentation/devicetree/bindings/rtc/epson,rtc7301.txt b/Documentation/devicetree/bindings/rtc/epson,rtc7301.txt
new file mode 100644
index 0000000..5f9df3f
--- /dev/null
+++ b/Documentation/devicetree/bindings/rtc/epson,rtc7301.txt
@@ -0,0 +1,16 @@
+EPSON TOYOCOM RTC-7301SF/DG
+
+Required properties:
+
+- compatible: Should be "epson,rtc7301sf" or "epson,rtc7301dg"
+- reg: Specifies base physical address and size of the registers.
+- interrupts: A single interrupt specifier.
+
+Example:
+
+rtc: rtc@44a00000 {
+ compatible = "epson,rtc7301dg";
+ reg = <0x44a00000 0x10000>;
+ interrupt-parent = <&axi_intc_0>;
+ interrupts = <3 2>;
+};
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 0a5e058..b8f1f9c 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -1705,6 +1705,17 @@ config RTC_DRV_PIC32
This driver can also be built as a module. If so, the module
will be called rtc-pic32
+config RTC_DRV_R7301
+ tristate "EPSON TOYOCOM RTC-7301SF/DG"
+ select REGMAP_MMIO
+ depends on OF && HAS_IOMEM
+ help
+ If you say yes here you get support for the EPSON TOYOCOM
+ RTC-7301SF/DG chips.
+
+ This driver can also be built as a module. If so, the module
+ will be called rtc-r7301.
+
comment "HID Sensor RTC drivers"
config RTC_DRV_HID_SENSOR_TIME
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 1ac694a..f13ab1c 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -120,6 +120,7 @@ obj-$(CONFIG_RTC_DRV_PM8XXX) += rtc-pm8xxx.o
obj-$(CONFIG_RTC_DRV_PS3) += rtc-ps3.o
obj-$(CONFIG_RTC_DRV_PUV3) += rtc-puv3.o
obj-$(CONFIG_RTC_DRV_PXA) += rtc-pxa.o
+obj-$(CONFIG_RTC_DRV_R7301) += rtc-r7301.o
obj-$(CONFIG_RTC_DRV_R9701) += rtc-r9701.o
obj-$(CONFIG_RTC_DRV_RC5T583) += rtc-rc5t583.o
obj-$(CONFIG_RTC_DRV_RK808) += rtc-rk808.o
diff --git a/drivers/rtc/rtc-r7301.c b/drivers/rtc/rtc-r7301.c
new file mode 100644
index 0000000..0929f10
--- /dev/null
+++ b/drivers/rtc/rtc-r7301.c
@@ -0,0 +1,455 @@
+/*
+ * EPSON TOYOCOM RTC-7301SF/DG Driver
+ *
+ * Copyright (c) 2016 Akinobu Mita <akinobu.mita-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>
+ *
+ * Based on rtc-rp5c01.c
+ *
+ * Datasheet: http://www5.epsondevice.com/en/products/parallel/rtc7301sf.html
+ */
+
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/regmap.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+
+#define DRV_NAME "rtc-r7301"
+
+enum {
+ RTC7301_1_SEC = 0x0, /* Bank 0 and Band 1 */
+ RTC7301_10_SEC = 0x1, /* Bank 0 and Band 1 */
+ RTC7301_AE = BIT(3),
+ RTC7301_1_MIN = 0x2, /* Bank 0 and Band 1 */
+ RTC7301_10_MIN = 0x3, /* Bank 0 and Band 1 */
+ RTC7301_1_HOUR = 0x4, /* Bank 0 and Band 1 */
+ RTC7301_10_HOUR = 0x5, /* Bank 0 and Band 1 */
+ RTC7301_DAY_OF_WEEK = 0x6, /* Bank 0 and Band 1 */
+ RTC7301_1_DAY = 0x7, /* Bank 0 and Band 1 */
+ RTC7301_10_DAY = 0x8, /* Bank 0 and Band 1 */
+ RTC7301_1_MONTH = 0x9, /* Bank 0 */
+ RTC7301_10_MONTH = 0xa, /* Bank 0 */
+ RTC7301_1_YEAR = 0xb, /* Bank 0 */
+ RTC7301_10_YEAR = 0xc, /* Bank 0 */
+ RTC7301_100_YEAR = 0xd, /* Bank 0 */
+ RTC7301_1000_YEAR = 0xe, /* Bank 0 */
+ RTC7301_ALARM_CONTROL = 0xe, /* Bank 1 */
+ RTC7301_ALARM_CONTROL_AIE = BIT(0),
+ RTC7301_ALARM_CONTROL_AF = BIT(1),
+ RTC7301_TIMER_CONTROL = 0xe, /* Bank 2 */
+ RTC7301_TIMER_CONTROL_TIE = BIT(0),
+ RTC7301_TIMER_CONTROL_TF = BIT(1),
+ RTC7301_CONTROL = 0xf, /* All banks */
+ RTC7301_CONTROL_BUSY = BIT(0),
+ RTC7301_CONTROL_STOP = BIT(1),
+ RTC7301_CONTROL_BANK_SEL_0 = BIT(2),
+ RTC7301_CONTROL_BANK_SEL_1 = BIT(3),
+};
+
+struct rtc7301_priv {
+ struct regmap *regmap;
+ int irq;
+ spinlock_t lock;
+ u8 bank;
+};
+
+static const struct regmap_config rtc7301_regmap_config = {
+ .reg_bits = 32,
+ .val_bits = 8,
+ .reg_stride = 4,
+};
+
+static u8 rtc7301_read(struct rtc7301_priv *priv, unsigned int reg)
+{
+ int reg_stride = regmap_get_reg_stride(priv->regmap);
+ unsigned int val;
+
+ regmap_read(priv->regmap, reg_stride * reg, &val);
+
+ return val & 0xf;
+}
+
+static void rtc7301_write(struct rtc7301_priv *priv, u8 val, unsigned int reg)
+{
+ int reg_stride = regmap_get_reg_stride(priv->regmap);
+
+ regmap_write(priv->regmap, reg_stride * reg, val);
+}
+
+static void rtc7301_update_bits(struct rtc7301_priv *priv, unsigned int reg,
+ u8 mask, u8 val)
+{
+ int reg_stride = regmap_get_reg_stride(priv->regmap);
+
+ regmap_update_bits(priv->regmap, reg_stride * reg, mask, val);
+}
+
+static int rtc7301_wait_while_busy(struct rtc7301_priv *priv)
+{
+ int retries = 100;
+
+ while (retries-- > 0) {
+ u8 val;
+
+ val = rtc7301_read(priv, RTC7301_CONTROL);
+ if (!(val & RTC7301_CONTROL_BUSY))
+ return 0;
+
+ usleep_range(200, 300);
+ }
+
+ return -ETIMEDOUT;
+}
+
+static void rtc7301_stop(struct rtc7301_priv *priv)
+{
+ rtc7301_update_bits(priv, RTC7301_CONTROL, RTC7301_CONTROL_STOP,
+ RTC7301_CONTROL_STOP);
+}
+
+static void rtc7301_start(struct rtc7301_priv *priv)
+{
+ rtc7301_update_bits(priv, RTC7301_CONTROL, RTC7301_CONTROL_STOP, 0);
+}
+
+static void rtc7301_select_bank(struct rtc7301_priv *priv, u8 bank)
+{
+ u8 val = 0;
+
+ if (bank == priv->bank)
+ return;
+
+ if (bank & BIT(0))
+ val |= RTC7301_CONTROL_BANK_SEL_0;
+ if (bank & BIT(1))
+ val |= RTC7301_CONTROL_BANK_SEL_1;
+
+ rtc7301_update_bits(priv, RTC7301_CONTROL,
+ RTC7301_CONTROL_BANK_SEL_0 |
+ RTC7301_CONTROL_BANK_SEL_1, val);
+
+ priv->bank = bank;
+}
+
+static void rtc7301_get_time(struct rtc7301_priv *priv, struct rtc_time *tm,
+ bool alarm)
+{
+ int year;
+
+ tm->tm_sec = rtc7301_read(priv, RTC7301_1_SEC);
+ tm->tm_sec += (rtc7301_read(priv, RTC7301_10_SEC) & ~RTC7301_AE) * 10;
+ tm->tm_min = rtc7301_read(priv, RTC7301_1_MIN);
+ tm->tm_min += (rtc7301_read(priv, RTC7301_10_MIN) & ~RTC7301_AE) * 10;
+ tm->tm_hour = rtc7301_read(priv, RTC7301_1_HOUR);
+ tm->tm_hour += (rtc7301_read(priv, RTC7301_10_HOUR) & ~RTC7301_AE) * 10;
+ tm->tm_mday = rtc7301_read(priv, RTC7301_1_DAY);
+ tm->tm_mday += (rtc7301_read(priv, RTC7301_10_DAY) & ~RTC7301_AE) * 10;
+
+ if (alarm) {
+ tm->tm_wday = -1;
+ tm->tm_mon = -1;
+ tm->tm_year = -1;
+ tm->tm_yday = -1;
+ tm->tm_isdst = -1;
+ return;
+ }
+
+ tm->tm_wday = (rtc7301_read(priv, RTC7301_DAY_OF_WEEK) & ~RTC7301_AE);
+ tm->tm_mon = rtc7301_read(priv, RTC7301_10_MONTH) * 10 +
+ rtc7301_read(priv, RTC7301_1_MONTH) - 1;
+ year = rtc7301_read(priv, RTC7301_1000_YEAR) * 1000 +
+ rtc7301_read(priv, RTC7301_100_YEAR) * 100 +
+ rtc7301_read(priv, RTC7301_10_YEAR) * 10 +
+ rtc7301_read(priv, RTC7301_1_YEAR);
+
+ tm->tm_year = year - 1900;
+}
+
+static void rtc7301_write_time(struct rtc7301_priv *priv, struct rtc_time *tm,
+ bool alarm)
+{
+ int year;
+
+ rtc7301_write(priv, tm->tm_sec % 10, RTC7301_1_SEC);
+ rtc7301_write(priv, tm->tm_sec / 10, RTC7301_10_SEC);
+
+ rtc7301_write(priv, tm->tm_min % 10, RTC7301_1_MIN);
+ rtc7301_write(priv, tm->tm_min / 10, RTC7301_10_MIN);
+
+ rtc7301_write(priv, tm->tm_hour % 10, RTC7301_1_HOUR);
+ rtc7301_write(priv, tm->tm_hour / 10, RTC7301_10_HOUR);
+
+ rtc7301_write(priv, tm->tm_mday % 10, RTC7301_1_DAY);
+ rtc7301_write(priv, tm->tm_mday / 10, RTC7301_10_DAY);
+
+ /* Don't care for alarm register */
+ rtc7301_write(priv, alarm ? RTC7301_AE : tm->tm_wday,
+ RTC7301_DAY_OF_WEEK);
+
+ if (alarm)
+ return;
+
+ rtc7301_write(priv, (tm->tm_mon + 1) % 10, RTC7301_1_MONTH);
+ rtc7301_write(priv, (tm->tm_mon + 1) / 10, RTC7301_10_MONTH);
+
+ year = tm->tm_year + 1900;
+
+ rtc7301_write(priv, year % 10, RTC7301_1_YEAR);
+ rtc7301_write(priv, (year / 10) % 10, RTC7301_10_YEAR);
+ rtc7301_write(priv, (year / 100) % 10, RTC7301_100_YEAR);
+ rtc7301_write(priv, year / 1000, RTC7301_1000_YEAR);
+}
+
+static void rtc7301_alarm_irq(struct rtc7301_priv *priv, unsigned int enabled)
+{
+ rtc7301_update_bits(priv, RTC7301_ALARM_CONTROL,
+ RTC7301_ALARM_CONTROL_AF |
+ RTC7301_ALARM_CONTROL_AIE,
+ enabled ? RTC7301_ALARM_CONTROL_AIE : 0);
+}
+
+static int rtc7301_read_time(struct device *dev, struct rtc_time *tm)
+{
+ struct rtc7301_priv *priv = dev_get_drvdata(dev);
+ unsigned long flags;
+ int err;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ rtc7301_select_bank(priv, 0);
+
+ err = rtc7301_wait_while_busy(priv);
+ if (!err)
+ rtc7301_get_time(priv, tm, false);
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return err ? err : rtc_valid_tm(tm);
+}
+
+static int rtc7301_set_time(struct device *dev, struct rtc_time *tm)
+{
+ struct rtc7301_priv *priv = dev_get_drvdata(dev);
+ unsigned long flags;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ rtc7301_stop(priv);
+ usleep_range(200, 300);
+ rtc7301_select_bank(priv, 0);
+ rtc7301_write_time(priv, tm, false);
+ rtc7301_start(priv);
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return 0;
+}
+
+static int rtc7301_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+ struct rtc7301_priv *priv = dev_get_drvdata(dev);
+ unsigned long flags;
+ u8 alrm_ctrl;
+
+ if (priv->irq <= 0)
+ return -EINVAL;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ rtc7301_select_bank(priv, 1);
+ rtc7301_get_time(priv, &alarm->time, true);
+
+ alrm_ctrl = rtc7301_read(priv, RTC7301_ALARM_CONTROL);
+
+ alarm->enabled = !!(alrm_ctrl & RTC7301_ALARM_CONTROL_AIE);
+ alarm->pending = !!(alrm_ctrl & RTC7301_ALARM_CONTROL_AF);
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return 0;
+}
+
+static int rtc7301_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+ struct rtc7301_priv *priv = dev_get_drvdata(dev);
+ unsigned long flags;
+
+ if (priv->irq <= 0)
+ return -EINVAL;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ rtc7301_select_bank(priv, 1);
+ rtc7301_write_time(priv, &alarm->time, true);
+ rtc7301_alarm_irq(priv, alarm->enabled);
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return 0;
+}
+
+static int rtc7301_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+ struct rtc7301_priv *priv = dev_get_drvdata(dev);
+ unsigned long flags;
+
+ if (priv->irq <= 0)
+ return -EINVAL;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ rtc7301_select_bank(priv, 1);
+ rtc7301_alarm_irq(priv, enabled);
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return 0;
+}
+
+static const struct rtc_class_ops rtc7301_rtc_ops = {
+ .read_time = rtc7301_read_time,
+ .set_time = rtc7301_set_time,
+ .read_alarm = rtc7301_read_alarm,
+ .set_alarm = rtc7301_set_alarm,
+ .alarm_irq_enable = rtc7301_alarm_irq_enable,
+};
+
+static irqreturn_t rtc7301_irq_handler(int irq, void *dev_id)
+{
+ struct rtc_device *rtc = dev_id;
+ struct rtc7301_priv *priv = dev_get_drvdata(rtc->dev.parent);
+ unsigned long flags;
+ irqreturn_t ret = IRQ_NONE;
+ u8 alrm_ctrl;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ rtc7301_select_bank(priv, 1);
+
+ alrm_ctrl = rtc7301_read(priv, RTC7301_ALARM_CONTROL);
+ if (alrm_ctrl & RTC7301_ALARM_CONTROL_AF) {
+ ret = IRQ_HANDLED;
+ rtc7301_alarm_irq(priv, false);
+ rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF);
+ }
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return ret;
+}
+
+static void rtc7301_init(struct rtc7301_priv *priv)
+{
+ unsigned long flags;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ rtc7301_select_bank(priv, 2);
+ rtc7301_write(priv, 0, RTC7301_TIMER_CONTROL);
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+static int __init rtc7301_rtc_probe(struct platform_device *dev)
+{
+ struct resource *res;
+ void __iomem *regs;
+ struct rtc7301_priv *priv;
+ struct rtc_device *rtc;
+ int ret;
+
+ res = platform_get_resource(dev, IORESOURCE_MEM, 0);
+ if (!res)
+ return -ENODEV;
+
+ priv = devm_kzalloc(&dev->dev, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
+ regs = devm_ioremap_resource(&dev->dev, res);
+ if (IS_ERR(regs))
+ return PTR_ERR(regs);
+
+ priv->regmap = devm_regmap_init_mmio(&dev->dev, regs,
+ &rtc7301_regmap_config);
+ if (IS_ERR(priv->regmap))
+ return PTR_ERR(priv->regmap);
+
+ priv->irq = platform_get_irq(dev, 0);
+
+ spin_lock_init(&priv->lock);
+ priv->bank = -1;
+
+ rtc7301_init(priv);
+
+ platform_set_drvdata(dev, priv);
+
+ rtc = devm_rtc_device_register(&dev->dev, DRV_NAME, &rtc7301_rtc_ops,
+ THIS_MODULE);
+ if (IS_ERR(rtc))
+ return PTR_ERR(rtc);
+
+ if (priv->irq > 0) {
+ ret = devm_request_irq(&dev->dev, priv->irq,
+ rtc7301_irq_handler, IRQF_SHARED,
+ dev_name(&dev->dev), rtc);
+ if (ret) {
+ priv->irq = 0;
+ dev_err(&dev->dev, "unable to request IRQ\n");
+ } else {
+ device_set_wakeup_capable(&dev->dev, true);
+ }
+ }
+
+ return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+
+static int rtc7301_suspend(struct device *dev)
+{
+ struct rtc7301_priv *priv = dev_get_drvdata(dev);
+
+ if (device_may_wakeup(dev))
+ enable_irq_wake(priv->irq);
+
+ return 0;
+}
+
+static int rtc7301_resume(struct device *dev)
+{
+ struct rtc7301_priv *priv = dev_get_drvdata(dev);
+
+ if (device_may_wakeup(dev))
+ disable_irq_wake(priv->irq);
+
+ return 0;
+}
+
+#endif
+
+static SIMPLE_DEV_PM_OPS(rtc7301_pm_ops, rtc7301_suspend, rtc7301_resume);
+
+static const struct of_device_id rtc7301_dt_match[] = {
+ { .compatible = "epson,rtc7301sf" },
+ { .compatible = "epson,rtc7301dg" },
+ {}
+};
+MODULE_DEVICE_TABLE(of, rtc7301_dt_match);
+
+static struct platform_driver rtc7301_rtc_driver = {
+ .driver = {
+ .name = DRV_NAME,
+ .of_match_table = rtc7301_dt_match,
+ .pm = &rtc7301_pm_ops,
+ },
+};
+
+module_platform_driver_probe(rtc7301_rtc_driver, rtc7301_rtc_probe);
+
+MODULE_AUTHOR("Akinobu Mita <akinobu.mita-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("EPSON TOYOCOM RTC-7301SF/DG Driver");
+MODULE_ALIAS("platform:rtc-r7301");
--
2.7.4
--
You received this message because you are subscribed to "rtc-linux".
Membership options at http://groups.google.com/group/rtc-linux .
Please read http://groups.google.com/group/rtc-linux/web/checklist
before submitting a driver.
---
You received this message because you are subscribed to the Google Groups "rtc-linux" group.
To unsubscribe from this group and stop receiving emails from it, send an email to rtc-linux+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/Ez6ZCGd0@public.gmane.org
For more options, visit https://groups.google.com/d/optout.
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox