lkml.org 
[lkml]   [2016]   [Dec]   [13]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v2 1/3] drivers: crypto: Add Support for Octeon-tx CPT Engine
    Date
    Enable the Physical Function diver for the Cavium Crypto Engine (CPT)
    found in Octeon-tx series of SoC's. CPT is the Cryptographic Acceleration
    Unit. CPT includes microcoded GigaCypher symmetric engines (SEs) and
    asymmetric engines (AEs).

    Signed-off-by: George Cherian <george.cherian@cavium.com>
    ---
    drivers/crypto/cavium/cpt/Kconfig | 16 +
    drivers/crypto/cavium/cpt/Makefile | 2 +
    drivers/crypto/cavium/cpt/cpt_common.h | 166 +++++++
    drivers/crypto/cavium/cpt/cpt_hw_types.h | 736 +++++++++++++++++++++++++++++++
    drivers/crypto/cavium/cpt/cptpf.h | 69 +++
    drivers/crypto/cavium/cpt/cptpf_main.c | 733 ++++++++++++++++++++++++++++++
    drivers/crypto/cavium/cpt/cptpf_mbox.c | 163 +++++++
    7 files changed, 1885 insertions(+)
    create mode 100644 drivers/crypto/cavium/cpt/Kconfig
    create mode 100644 drivers/crypto/cavium/cpt/Makefile
    create mode 100644 drivers/crypto/cavium/cpt/cpt_common.h
    create mode 100644 drivers/crypto/cavium/cpt/cpt_hw_types.h
    create mode 100644 drivers/crypto/cavium/cpt/cptpf.h
    create mode 100644 drivers/crypto/cavium/cpt/cptpf_main.c
    create mode 100644 drivers/crypto/cavium/cpt/cptpf_mbox.c

    diff --git a/drivers/crypto/cavium/cpt/Kconfig b/drivers/crypto/cavium/cpt/Kconfig
    new file mode 100644
    index 0000000..247f1cb
    --- /dev/null
    +++ b/drivers/crypto/cavium/cpt/Kconfig
    @@ -0,0 +1,16 @@
    +#
    +# Cavium crypto device configuration
    +#
    +
    +config CRYPTO_DEV_CPT
    + tristate
    +
    +config CAVIUM_CPT
    + tristate "Cavium Cryptographic Accelerator driver"
    + depends on ARCH_THUNDER
    + select CRYPTO_DEV_CPT
    + help
    + Support for Cavium CPT block found in octeon-tx series of
    + processors.
    +
    + To compile this as a module, choose M here.
    diff --git a/drivers/crypto/cavium/cpt/Makefile b/drivers/crypto/cavium/cpt/Makefile
    new file mode 100644
    index 0000000..fe3d454
    --- /dev/null
    +++ b/drivers/crypto/cavium/cpt/Makefile
    @@ -0,0 +1,2 @@
    +obj-$(CONFIG_CAVIUM_CPT) += cptpf.o
    +cptpf-objs := cptpf_main.o cptpf_mbox.o
    diff --git a/drivers/crypto/cavium/cpt/cpt_common.h b/drivers/crypto/cavium/cpt/cpt_common.h
    new file mode 100644
    index 0000000..ae542f4
    --- /dev/null
    +++ b/drivers/crypto/cavium/cpt/cpt_common.h
    @@ -0,0 +1,166 @@
    +/*
    + * Copyright (C) 2016 Cavium, Inc.
    + *
    + * This program is free software; you can redistribute it and/or modify it
    + * under the terms of version 2 of the GNU General Public License
    + * as published by the Free Software Foundation.
    + */
    +
    +#ifndef __CPT_COMMON_H
    +#define __CPT_COMMON_H
    +
    +#include <asm/byteorder.h>
    +#include <linux/delay.h>
    +#include <linux/pci.h>
    +
    +#include "cpt_hw_types.h"
    +
    +/* Device ID */
    +#define CPT_81XX_PCI_PF_DEVICE_ID 0xa040
    +#define CPT_81XX_PCI_VF_DEVICE_ID 0xa041
    +
    +/**< flags to indicate the features supported */
    +#define CPT_FLAG_MSIX_ENABLED BIT(0)
    +#define CPT_FLAG_SRIOV_ENABLED BIT(1)
    +#define CPT_FLAG_VF_DRIVER BIT(2)
    +#define CPT_FLAG_DEVICE_READY BIT(3)
    +
    +#define cpt_msix_enabled(cpt) ((cpt)->flags & CPT_FLAG_MSIX_ENABLED)
    +#define cpt_sriov_enabled(cpt) ((cpt)->flags & CPT_FLAG_SRIOV_ENABLED)
    +#define cpt_vf_driver(cpt) ((cpt)->flags & CPT_FLAG_VF_DRIVER)
    +#define cpt_device_ready(cpt) ((cpt)->flags & CPT_FLAG_DEVICE_READY)
    +
    +#define CPT_MBOX_MSG_TYPE_ACK 1
    +#define CPT_MBOX_MSG_TYPE_NACK 2
    +#define CPT_MBOX_MSG_TIMEOUT 2000
    +#define VF_STATE_DOWN 0
    +#define VF_STATE_UP 1
    +
    +/*
    + * CPT Registers map for 81xx
    + */
    +
    +/* PF registers */
    +#define CPTX_PF_CONSTANTS(a) (0x0ll + ((u64)(a) << 36))
    +#define CPTX_PF_RESET(a) (0x100ll + ((u64)(a) << 36))
    +#define CPTX_PF_DIAG(a) (0x120ll + ((u64)(a) << 36))
    +#define CPTX_PF_BIST_STATUS(a) (0x160ll + ((u64)(a) << 36))
    +#define CPTX_PF_ECC0_CTL(a) (0x200ll + ((u64)(a) << 36))
    +#define CPTX_PF_ECC0_FLIP(a) (0x210ll + ((u64)(a) << 36))
    +#define CPTX_PF_ECC0_INT(a) (0x220ll + ((u64)(a) << 36))
    +#define CPTX_PF_ECC0_INT_W1S(a) (0x230ll + ((u64)(a) << 36))
    +#define CPTX_PF_ECC0_ENA_W1S(a) (0x240ll + ((u64)(a) << 36))
    +#define CPTX_PF_ECC0_ENA_W1C(a) (0x250ll + ((u64)(a) << 36))
    +#define CPTX_PF_MBOX_INTX(a, b) \
    + (0x400ll + ((u64)(a) << 36) + ((b) << 3))
    +#define CPTX_PF_MBOX_INT_W1SX(a, b) \
    + (0x420ll + ((u64)(a) << 36) + ((b) << 3))
    +#define CPTX_PF_MBOX_ENA_W1CX(a, b) \
    + (0x440ll + ((u64)(a) << 36) + ((b) << 3))
    +#define CPTX_PF_MBOX_ENA_W1SX(a, b) \
    + (0x460ll + ((u64)(a) << 36) + ((b) << 3))
    +#define CPTX_PF_EXEC_INT(a) (0x500ll + 0x1000000000ll * ((a) & 0x1))
    +#define CPTX_PF_EXEC_INT_W1S(a) (0x520ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXEC_ENA_W1C(a) (0x540ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXEC_ENA_W1S(a) (0x560ll + ((u64)(a) << 36))
    +#define CPTX_PF_GX_EN(a, b) \
    + (0x600ll + ((u64)(a) << 36) + ((b) << 3))
    +#define CPTX_PF_EXEC_INFO(a) (0x700ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXEC_BUSY(a) (0x800ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXEC_INFO0(a) (0x900ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXEC_INFO1(a) (0x910ll + ((u64)(a) << 36))
    +#define CPTX_PF_INST_REQ_PC(a) (0x10000ll + ((u64)(a) << 36))
    +#define CPTX_PF_INST_LATENCY_PC(a) \
    + (0x10020ll + ((u64)(a) << 36))
    +#define CPTX_PF_RD_REQ_PC(a) (0x10040ll + ((u64)(a) << 36))
    +#define CPTX_PF_RD_LATENCY_PC(a) (0x10060ll + ((u64)(a) << 36))
    +#define CPTX_PF_RD_UC_PC(a) (0x10080ll + ((u64)(a) << 36))
    +#define CPTX_PF_ACTIVE_CYCLES_PC(a) (0x10100ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXE_CTL(a) (0x4000000ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXE_STATUS(a) (0x4000008ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXE_CLK(a) (0x4000010ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXE_DBG_CTL(a) (0x4000018ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXE_DBG_DATA(a) (0x4000020ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXE_BIST_STATUS(a) (0x4000028ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXE_REQ_TIMER(a) (0x4000030ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXE_MEM_CTL(a) (0x4000038ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXE_PERF_CTL(a) (0x4001000ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXE_DBG_CNTX(a, b) \
    + (0x4001100ll + ((u64)(a) << 36) + ((b) << 3))
    +#define CPTX_PF_EXE_PERF_EVENT_CNT(a) (0x4001180ll + ((u64)(a) << 36))
    +#define CPTX_PF_EXE_EPCI_INBX_CNT(a, b) \
    + (0x4001200ll + ((u64)(a) << 36) + ((b) << 3))
    +#define CPTX_PF_EXE_EPCI_OUTBX_CNT(a, b) \
    + (0x4001240ll + ((u64)(a) << 36) + ((b) << 3))
    +#define CPTX_PF_ENGX_UCODE_BASE(a, b) \
    + (0x4002000ll + ((u64)(a) << 36) + ((b) << 3))
    +#define CPTX_PF_QX_CTL(a, b) \
    + (0x8000000ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_PF_QX_GMCTL(a, b) \
    + (0x8000020ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_PF_QX_CTL2(a, b) \
    + (0x8000100ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_PF_VFX_MBOXX(a, b, c) \
    + (0x8001000ll + ((u64)(a) << 36) + ((b) << 20) + ((c) << 8))
    +
    +/* VF registers */
    +#define CPTX_VQX_CTL(a, b) (0x100ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VQX_SADDR(a, b) (0x200ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VQX_DONE_WAIT(a, b) (0x400ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VQX_INPROG(a, b) (0x410ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VQX_DONE(a, b) (0x420ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VQX_DONE_ACK(a, b) (0x440ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VQX_DONE_INT_W1S(a, b) (0x460ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VQX_DONE_INT_W1C(a, b) (0x468ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VQX_DONE_ENA_W1S(a, b) (0x470ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VQX_DONE_ENA_W1C(a, b) (0x478ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VQX_MISC_INT(a, b) (0x500ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VQX_MISC_INT_W1S(a, b) (0x508ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VQX_MISC_ENA_W1S(a, b) (0x510ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VQX_MISC_ENA_W1C(a, b) (0x518ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VQX_DOORBELL(a, b) (0x600ll + ((u64)(a) << 36) + ((b) << 20))
    +#define CPTX_VFX_PF_MBOXX(a, b, c) \
    + (0x1000ll + ((u64)(a) << 36) + ((b) << 20) + ((c) << 3))
    +
    +enum vftype {
    + AE_TYPES = 1,
    + SE_TYPES = 2,
    + BAD_CPT_TYPES,
    +};
    +
    +/* Max CPT devices supported */
    +enum cpt_mbox_opcode {
    + CPT_MSG_VF_UP = 1,
    + CPT_MSG_VF_DOWN,
    + CPT_MSG_READY,
    + CPT_MSG_QLEN,
    + CPT_MSG_QBIND_GRP,
    + CPT_MSG_VQ_PRIORITY,
    +};
    +
    +/* CPT mailbox structure */
    +struct cpt_mbox {
    + u64 msg; /* Message type MBOX[0] */
    + u64 data;/* Data MBOX[1] */
    +};
    +
    +/* The Cryptographic Acceleration Unit can *only* be found in SoCs
    + * containing the ThunderX ARM64 CPU implementation. All accesses to the device
    + * registers on this platform are implicitly strongly ordered with respect
    + * to memory accesses. So writeq_relaxed() and readq_relaxed() are safe to use
    + * with no memory barriers in this driver. The readq()/writeq() functions add
    + * explicit ordering operation which in this case are redundant, and only
    + * add overhead.
    + */
    +/* Register read/write APIs */
    +static inline void cpt_write_csr64(u8 __iomem *hw_addr, u64 offset,
    + u64 val)
    +{
    + writeq_relaxed(val, hw_addr + offset);
    +}
    +
    +static inline u64 cpt_read_csr64(u8 __iomem *hw_addr, u64 offset)
    +{
    + return readq_relaxed(hw_addr + offset);
    +}
    +#endif /* __CPT_COMMON_H */
    diff --git a/drivers/crypto/cavium/cpt/cpt_hw_types.h b/drivers/crypto/cavium/cpt/cpt_hw_types.h
    new file mode 100644
    index 0000000..3798803
    --- /dev/null
    +++ b/drivers/crypto/cavium/cpt/cpt_hw_types.h
    @@ -0,0 +1,736 @@
    +/*
    + * Copyright (C) 2016 Cavium, Inc.
    + *
    + * This program is free software; you can redistribute it and/or modify it
    + * under the terms of version 2 of the GNU General Public License
    + * as published by the Free Software Foundation.
    + */
    +
    +#ifndef __CPT_HW_TYPES_H
    +#define __CPT_HW_TYPES_H
    +
    +#include "cpt_common.h"
    +
    +/**
    + * Enumeration cpt_comp_e
    + *
    + * CPT Completion Enumeration
    + * Enumerates the values of CPT_RES_S[COMPCODE].
    + */
    +enum cpt_comp_e {
    + CPT_COMP_E_NOTDONE = 0x00,
    + CPT_COMP_E_GOOD = 0x01,
    + CPT_COMP_E_FAULT = 0x02,
    + CPT_COMP_E_SWERR = 0x03,
    + CPT_COMP_E_LAST_ENTRY = 0xFF
    +};
    +
    +/**
    + * Structure cpt_inst_s
    + *
    + * CPT Instruction Structure
    + * This structure specifies the instruction layout. Instructions are
    + * stored in memory as little-endian unless CPT()_PF_Q()_CTL[INST_BE] is set.
    + * cpt_inst_s_s
    + * Word 0
    + * doneint:1 Done interrupt.
    + * 0 = No interrupts related to this instruction.
    + * 1 = When the instruction completes, CPT()_VQ()_DONE[DONE] will be
    + * incremented,and based on the rules described there an interrupt may
    + * occur.
    + * Word 1
    + * res_addr:64 [127: 64] Result IOVA.
    + * If nonzero, specifies where to write CPT_RES_S.
    + * If zero, no result structure will be written.
    + * Address must be 16-byte aligned.
    + * Bits <63:49> are ignored by hardware; software should use a
    + * sign-extended bit <48> for forward compatibility.
    + * Word 2
    + * grp:10 [171:162] If [WQ_PTR] is nonzero, the SSO guest-group to use when
    + * CPT submits work SSO.
    + * For the SSO to not discard the add-work request, FPA_PF_MAP() must map
    + * [GRP] and CPT()_PF_Q()_GMCTL[GMID] as valid.
    + * tt:2 [161:160] If [WQ_PTR] is nonzero, the SSO tag type to use when CPT
    + * submits work to SSO
    + * tag:32 [159:128] If [WQ_PTR] is nonzero, the SSO tag to use when CPT
    + * submits work to SSO.
    + * Word 3
    + * wq_ptr:64 [255:192] If [WQ_PTR] is nonzero, it is a pointer to a
    + * work-queue entry that CPT submits work to SSO after all context,
    + * output data, and result write operations are visible to other
    + * CNXXXX units and the cores. Bits <2:0> must be zero.
    + * Bits <63:49> are ignored by hardware; software should
    + * use a sign-extended bit <48> for forward compatibility.
    + * Internal:
    + * Bits <63:49>, <2:0> are ignored by hardware, treated as always 0x0.
    + * Word 4
    + * ei0:64; [319:256] Engine instruction word 0. Passed to the AE/SE.
    + * Word 5
    + * ei1:64; [383:320] Engine instruction word 1. Passed to the AE/SE.
    + * Word 6
    + * ei2:64; [447:384] Engine instruction word 1. Passed to the AE/SE.
    + * Word 7
    + * ei3:64; [511:448] Engine instruction word 1. Passed to the AE/SE.
    + *
    + */
    +union cpt_inst_s {
    + u64 u[8];
    + struct cpt_inst_s_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_17_63:47;
    + u64 doneint:1;
    + u64 reserved_0_1:16;
    +#else /* Word 0 - Little Endian */
    + u64 reserved_0_15:16;
    + u64 doneint:1;
    + u64 reserved_17_63:47;
    +#endif /* Word 0 - End */
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 1 - Big Endian */
    + u64 res_addr:64;
    +#else /* Word 1 - Little Endian */
    + u64 res_addr:64;
    +#endif /* Word 1 - End */
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 2 - Big Endian */
    + u64 reserved_172_19:20;
    + u64 grp:10;
    + u64 tt:2;
    + u64 tag:32;
    +#else /* Word 2 - Little Endian */
    + u64 tag:32;
    + u64 tt:2;
    + u64 grp:10;
    + u64 reserved_172_191:20;
    +#endif /* Word 2 - End */
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 3 - Big Endian */
    + u64 wq_ptr:64;
    +#else /* Word 3 - Little Endian */
    + u64 wq_ptr:64;
    +#endif /* Word 3 - End */
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 4 - Big Endian */
    + u64 ei0:64;
    +#else /* Word 4 - Little Endian */
    + u64 ei0:64;
    +#endif /* Word 4 - End */
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 5 - Big Endian */
    + u64 ei1:64;
    +#else /* Word 5 - Little Endian */
    + u64 ei1:64;
    +#endif /* Word 5 - End */
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 6 - Big Endian */
    + u64 ei2:64;
    +#else /* Word 6 - Little Endian */
    + u64 ei2:64;
    +#endif /* Word 6 - End */
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 7 - Big Endian */
    + u64 ei3:64;
    +#else /* Word 7 - Little Endian */
    + u64 ei3:64;
    +#endif /* Word 7 - End */
    + } s;
    +};
    +
    +/**
    + * Structure cpt_res_s
    + *
    + * CPT Result Structure
    + * The CPT coprocessor writes the result structure after it completes a
    + * CPT_INST_S instruction. The result structure is exactly 16 bytes, and
    + * each instruction completion produces exactly one result structure.
    + *
    + * This structure is stored in memory as little-endian unless
    + * CPT()_PF_Q()_CTL[INST_BE] is set.
    + * cpt_res_s_s
    + * Word 0
    + * doneint:1 [16:16] Done interrupt. This bit is copied from the
    + * corresponding instruction's CPT_INST_S[DONEINT].
    + * compcode:8 [7:0] Indicates completion/error status of the CPT coprocessor
    + * for the associated instruction, as enumerated by CPT_COMP_E.
    + * Core software may write the memory location containing [COMPCODE] to
    + * 0x0 before ringing the doorbell, and then poll for completion by
    + * checking for a nonzero value.
    + * Once the core observes a nonzero [COMPCODE] value in this case,the CPT
    + * coprocessor will have also completed L2/DRAM write operations.
    + * Word 1
    + * reserved
    + *
    + */
    +union cpt_res_s {
    + u64 u[2];
    + struct cpt_res_s_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_17_63:47;
    + u64 doneint:1;
    + u64 reserved_8_15:8;
    + u64 compcode:8;
    +#else /* Word 0 - Little Endian */
    + u64 compcode:8;
    + u64 reserved_8_15:8;
    + u64 doneint:1;
    + u64 reserved_17_63:47;
    +#endif /* Word 0 - End */
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 1 - Big Endian */
    + u64 reserved_64_127:64;
    +#else /* Word 1 - Little Endian */
    + u64 reserved_64_127:64;
    +#endif /* Word 1 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_pf_bist_status
    + *
    + * CPT PF Control Bist Status Register
    + * This register has the BIST status of memories. Each bit is the BIST result
    + * of an individual memory (per bit, 0 = pass and 1 = fail).
    + * cptx_pf_bist_status_s
    + * Word0
    + * bstatus [29:0](RO/H) BIST status. One bit per memory, enumerated by
    + * CPT_RAMS_E.
    + */
    +union cptx_pf_bist_status {
    + u64 u;
    + struct cptx_pf_bist_status_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_30_63:34;
    + u64 bstatus:30;
    +#else /* Word 0 - Little Endian */
    + u64 bstatus:30;
    + u64 reserved_30_63:34;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_pf_constants
    + *
    + * CPT PF Constants Register
    + * This register contains implementation-related parameters of CPT in CNXXXX.
    + * cptx_pf_constants_s
    + * Word 0
    + * reserved_40_63:24 [63:40] Reserved.
    + * epcis:8 [39:32](RO) Number of EPCI busses.
    + * grps:8 [31:24](RO) Number of engine groups implemented.
    + * ae:8 [23:16](RO/H) Number of AEs. In CNXXXX, for CPT0 returns 0x0,
    + * for CPT1 returns 0x18, or less if there are fuse-disables.
    + * se:8 [15:8](RO/H) Number of SEs. In CNXXXX, for CPT0 returns 0x30,
    + * or less if there are fuse-disables, for CPT1 returns 0x0.
    + * vq:8 [7:0](RO) Number of VQs.
    + */
    +union cptx_pf_constants {
    + u64 u;
    + struct cptx_pf_constants_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_40_63:24;
    + u64 epcis:8;
    + u64 grps:8;
    + u64 ae:8;
    + u64 se:8;
    + u64 vq:8;
    +#else /* Word 0 - Little Endian */
    + u64 vq:8;
    + u64 se:8;
    + u64 ae:8;
    + u64 grps:8;
    + u64 epcis:8;
    + u64 reserved_40_63:24;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_pf_exe_bist_status
    + *
    + * CPT PF Engine Bist Status Register
    + * This register has the BIST status of each engine. Each bit is the
    + * BIST result of an individual engine (per bit, 0 = pass and 1 = fail).
    + * cptx_pf_exe_bist_status_s
    + * Word0
    + * reserved_48_63:16 [63:48] reserved
    + * bstatus:48 [47:0](RO/H) BIST status. One bit per engine.
    + *
    + */
    +union cptx_pf_exe_bist_status {
    + u64 u;
    + struct cptx_pf_exe_bist_status_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_48_63:16;
    + u64 bstatus:48;
    +#else /* Word 0 - Little Endian */
    + u64 bstatus:48;
    + u64 reserved_48_63:16;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_pf_exe_ctl
    + *
    + * CPT PF Engine Control Register
    + * This register enables the engines.
    + * cptx_pf_exe_ctl_s
    + * Word0
    + * enable:64 [63:0](R/W) Individual enables for each of the engines.
    + */
    +union cptx_pf_exe_ctl {
    + u64 u;
    + struct cptx_pf_exe_ctl_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 enable:64;
    +#else /* Word 0 - Little Endian */
    + u64 enable:64;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_pf_q#_ctl
    + *
    + * CPT Queue Control Register
    + * This register configures queues. This register should be changed only
    + * when quiescent (see CPT()_VQ()_INPROG[INFLIGHT]).
    + * cptx_pf_qx_ctl_s
    + * Word0
    + * reserved_60_63:4 [63:60] reserved.
    + * aura:12; [59:48](R/W) Guest-aura for returning this queue's
    + * instruction-chunk buffers to FPA. Only used when [INST_FREE] is set.
    + * For the FPA to not discard the request, FPA_PF_MAP() must map
    + * [AURA] and CPT()_PF_Q()_GMCTL[GMID] as valid.
    + * reserved_45_47:3 [47:45] reserved.
    + * size:13 [44:32](R/W) Command-buffer size, in number of 64-bit words per
    + * command buffer segment. Must be 8*n + 1, where n is the number of
    + * instructions per buffer segment.
    + * reserved_11_31:21 [31:11] Reserved.
    + * cont_err:1 [10:10](R/W) Continue on error.
    + * 0 = When CPT()_VQ()_MISC_INT[NWRP], CPT()_VQ()_MISC_INT[IRDE] or
    + * CPT()_VQ()_MISC_INT[DOVF] are set by hardware or software via
    + * CPT()_VQ()_MISC_INT_W1S, then CPT()_VQ()_CTL[ENA] is cleared. Due to
    + * pipelining, additional instructions may have been processed between the
    + * instruction causing the error and the next instruction in the disabled
    + * queue (the instruction at CPT()_VQ()_SADDR).
    + * 1 = Ignore errors and continue processing instructions.
    + * For diagnostic use only.
    + * inst_free:1 [9:9](R/W) Instruction FPA free. When set, when CPT reaches the
    + * end of an instruction chunk, that chunk will be freed to the FPA.
    + * inst_be:1 [8:8](R/W) Instruction big-endian control. When set, instructions,
    + * instruction next chunk pointers, and result structures are stored in
    + * big-endian format in memory.
    + * iqb_ldwb:1 [7:7](R/W) Instruction load don't write back.
    + * 0 = The hardware issues NCB transient load (LDT) towards the cache,
    + * which if the line hits and is is dirty will cause the line to be
    + * written back before being replaced.
    + * 1 = The hardware issues NCB LDWB read-and-invalidate command towards
    + * the cache when fetching the last word of instructions; as a result the
    + * line will not be written back when replaced. This improves
    + * performance, but software must not read the instructions after they are
    + * posted to the hardware. Reads that do not consume the last word of a
    + * cache line always use LDI.
    + * reserved_4_6:3 [6:4] Reserved.
    + * grp:3; [3:1](R/W) Engine group.
    + * pri:1; [0:0](R/W) Queue priority.
    + * 1 = This queue has higher priority. Round-robin between higher
    + * priority queues.
    + * 0 = This queue has lower priority. Round-robin between lower
    + * priority queues.
    + */
    +union cptx_pf_qx_ctl {
    + u64 u;
    + struct cptx_pf_qx_ctl_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_60_63:4;
    + u64 aura:12;
    + u64 reserved_45_47:3;
    + u64 size:13;
    + u64 reserved_11_31:21;
    + u64 cont_err:1;
    + u64 inst_free:1;
    + u64 inst_be:1;
    + u64 iqb_ldwb:1;
    + u64 reserved_4_6:3;
    + u64 grp:3;
    + u64 pri:1;
    +#else /* Word 0 - Little Endian */
    + u64 pri:1;
    + u64 grp:3;
    + u64 reserved_4_6:3;
    + u64 iqb_ldwb:1;
    + u64 inst_be:1;
    + u64 inst_free:1;
    + u64 cont_err:1;
    + u64 reserved_11_31:21;
    + u64 size:13;
    + u64 reserved_45_47:3;
    + u64 aura:12;
    + u64 reserved_60_63:4;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_pf_g#_en
    + *
    + * CPT PF Group Control Register
    + * This register configures engine groups.
    + * cptx_pf_gx_en_s
    + * Word0
    + * en: 64; [63:0](R/W/H) Engine group enable. One bit corresponds to each
    + * engine, with the bit set to indicate this engine can service this group.
    + * Bits corresponding to unimplemented engines read as zero, i.e. only bit
    + * numbers less than CPT()_PF_CONSTANTS[AE] + CPT()_PF_CONSTANTS[SE] are
    + * writable. AE engine bits follow SE engine bits.
    + * E.g. if CPT()_PF_CONSTANTS[AE] = 0x1, and CPT()_PF_CONSTANTS[SE] = 0x2,
    + * then bits <2:0> are read/writable with bit <2> corresponding to AE<0>,
    + * and bit <1> to SE<1>, and bit<0> to SE<0>. Before disabling an engine,
    + * the corresponding bit in each group must be cleared. CPT()_PF_EXEC_BUSY
    + * can then be polled to determing when the engine becomes idle.
    + * At the point, the engine can be disabled.
    + */
    +union cptx_pf_gx_en {
    + u64 u;
    + struct cptx_pf_gx_en_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 en:64;
    +#else /* Word 0 - Little Endian */
    + u64 en:64;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_vq#_saddr
    + *
    + * CPT Queue Starting Buffer Address Registers
    + * These registers set the instruction buffer starting address.
    + * cptx_vqx_saddr_s
    + * Word0
    + * reserved_49_63:15 [63:49] Reserved.
    + * ptr:43 [48:6](R/W/H) Instruction buffer IOVA <48:6> (64-byte aligned).
    + * When written, it is the initial buffer starting address; when read,
    + * it is the next read pointer to be requested from L2C. The PTR field
    + * is overwritten with the next pointer each time that the command buffer
    + * segment is exhausted. New commands will then be read from the newly
    + * specified command buffer pointer.
    + * reserved_0_5:6 [5:0] Reserved.
    + *
    + */
    +union cptx_vqx_saddr {
    + u64 u;
    + struct cptx_vqx_saddr_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_49_63:15;
    + u64 ptr:43;
    + u64 reserved_0_5:6;
    +#else /* Word 0 - Little Endian */
    + u64 reserved_0_5:6;
    + u64 ptr:43;
    + u64 reserved_49_63:15;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_vq#_misc_ena_w1s
    + *
    + * CPT Queue Misc Interrupt Enable Set Register
    + * This register sets interrupt enable bits.
    + * cptx_vqx_misc_ena_w1s_s
    + * Word0
    + * reserved_5_63:59 [63:5] Reserved.
    + * swerr:1 [4:4](R/W1S/H) Reads or sets enable for
    + * CPT(0..1)_VQ(0..63)_MISC_INT[SWERR].
    + * nwrp:1 [3:3](R/W1S/H) Reads or sets enable for
    + * CPT(0..1)_VQ(0..63)_MISC_INT[NWRP].
    + * irde:1 [2:2](R/W1S/H) Reads or sets enable for
    + * CPT(0..1)_VQ(0..63)_MISC_INT[IRDE].
    + * dovf:1 [1:1](R/W1S/H) Reads or sets enable for
    + * CPT(0..1)_VQ(0..63)_MISC_INT[DOVF].
    + * mbox:1 [0:0](R/W1S/H) Reads or sets enable for
    + * CPT(0..1)_VQ(0..63)_MISC_INT[MBOX].
    + *
    + */
    +union cptx_vqx_misc_ena_w1s {
    + u64 u;
    + struct cptx_vqx_misc_ena_w1s_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_5_63:59;
    + u64 swerr:1;
    + u64 nwrp:1;
    + u64 irde:1;
    + u64 dovf:1;
    + u64 mbox:1;
    +#else /* Word 0 - Little Endian */
    + u64 mbox:1;
    + u64 dovf:1;
    + u64 irde:1;
    + u64 nwrp:1;
    + u64 swerr:1;
    + u64 reserved_5_63:59;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_vq#_doorbell
    + *
    + * CPT Queue Doorbell Registers
    + * Doorbells for the CPT instruction queues.
    + * cptx_vqx_doorbell_s
    + * Word0
    + * reserved_20_63:44 [63:20] Reserved.
    + * dbell_cnt:20 [19:0](R/W/H) Number of instruction queue 64-bit words to add
    + * to the CPT instruction doorbell count. Readback value is the the
    + * current number of pending doorbell requests. If counter overflows
    + * CPT()_VQ()_MISC_INT[DBELL_DOVF] is set. To reset the count back to
    + * zero, write one to clear CPT()_VQ()_MISC_INT_ENA_W1C[DBELL_DOVF],
    + * then write a value of 2^20 minus the read [DBELL_CNT], then write one
    + * to CPT()_VQ()_MISC_INT_W1C[DBELL_DOVF] and
    + * CPT()_VQ()_MISC_INT_ENA_W1S[DBELL_DOVF]. Must be a multiple of 8.
    + * All CPT instructions are 8 words and require a doorbell count of
    + * multiple of 8.
    + */
    +union cptx_vqx_doorbell {
    + u64 u;
    + struct cptx_vqx_doorbell_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_20_63:44;
    + u64 dbell_cnt:20;
    +#else /* Word 0 - Little Endian */
    + u64 dbell_cnt:20;
    + u64 reserved_20_63:44;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_vq#_inprog
    + *
    + * CPT Queue In Progress Count Registers
    + * These registers contain the per-queue instruction in flight registers.
    + * cptx_vqx_inprog_s
    + * Word0
    + * reserved_8_63:56 [63:8] Reserved.
    + * inflight:8 [7:0](RO/H) Inflight count. Counts the number of instructions
    + * for the VF for which CPT is fetching, executing or responding to
    + * instructions. However this does not include any interrupts that are
    + * awaiting software handling (CPT()_VQ()_DONE[DONE] != 0x0).
    + * A queue may not be reconfigured until:
    + * 1. CPT()_VQ()_CTL[ENA] is cleared by software.
    + * 2. [INFLIGHT] is polled until equals to zero.
    + */
    +union cptx_vqx_inprog {
    + u64 u;
    + struct cptx_vqx_inprog_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_8_63:56;
    + u64 inflight:8;
    +#else /* Word 0 - Little Endian */
    + u64 inflight:8;
    + u64 reserved_8_63:56;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_vq#_misc_int
    + *
    + * CPT Queue Misc Interrupt Register
    + * These registers contain the per-queue miscellaneous interrupts.
    + * cptx_vqx_misc_int_s
    + * Word 0
    + * reserved_5_63:59 [63:5] Reserved.
    + * swerr:1 [4:4](R/W1C/H) Software error from engines.
    + * nwrp:1 [3:3](R/W1C/H) NCB result write response error.
    + * irde:1 [2:2](R/W1C/H) Instruction NCB read response error.
    + * dovf:1 [1:1](R/W1C/H) Doorbell overflow.
    + * mbox:1 [0:0](R/W1C/H) PF to VF mailbox interrupt. Set when
    + * CPT()_VF()_PF_MBOX(0) is written.
    + *
    + */
    +union cptx_vqx_misc_int {
    + u64 u;
    + struct cptx_vqx_misc_int_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_5_63:59;
    + u64 swerr:1;
    + u64 nwrp:1;
    + u64 irde:1;
    + u64 dovf:1;
    + u64 mbox:1;
    +#else /* Word 0 - Little Endian */
    + u64 mbox:1;
    + u64 dovf:1;
    + u64 irde:1;
    + u64 nwrp:1;
    + u64 swerr:1;
    + u64 reserved_5_63:59;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_vq#_done_ack
    + *
    + * CPT Queue Done Count Ack Registers
    + * This register is written by software to acknowledge interrupts.
    + * cptx_vqx_done_ack_s
    + * Word0
    + * reserved_20_63:44 [63:20] Reserved.
    + * done_ack:20 [19:0](R/W/H) Number of decrements to CPT()_VQ()_DONE[DONE].
    + * Reads CPT()_VQ()_DONE[DONE]. Written by software to acknowledge
    + * interrupts. If CPT()_VQ()_DONE[DONE] is still nonzero the interrupt
    + * will be re-sent if the conditions described in CPT()_VQ()_DONE[DONE]
    + * are satisfied.
    + *
    + */
    +union cptx_vqx_done_ack {
    + u64 u;
    + struct cptx_vqx_done_ack_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_20_63:44;
    + u64 done_ack:20;
    +#else /* Word 0 - Little Endian */
    + u64 done_ack:20;
    + u64 reserved_20_63:44;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_vq#_done
    + *
    + * CPT Queue Done Count Registers
    + * These registers contain the per-queue instruction done count.
    + * cptx_vqx_done_s
    + * Word0
    + * reserved_20_63:44 [63:20] Reserved.
    + * done:20 [19:0](R/W/H) Done count. When CPT_INST_S[DONEINT] set and that
    + * instruction completes, CPT()_VQ()_DONE[DONE] is incremented when the
    + * instruction finishes. Write to this field are for diagnostic use only;
    + * instead software writes CPT()_VQ()_DONE_ACK with the number of
    + * decrements for this field.
    + * Interrupts are sent as follows:
    + * * When CPT()_VQ()_DONE[DONE] = 0, then no results are pending, the
    + * interrupt coalescing timer is held to zero, and an interrupt is not
    + * sent.
    + * * When CPT()_VQ()_DONE[DONE] != 0, then the interrupt coalescing timer
    + * counts. If the counter is >= CPT()_VQ()_DONE_WAIT[TIME_WAIT]*1024, or
    + * CPT()_VQ()_DONE[DONE] >= CPT()_VQ()_DONE_WAIT[NUM_WAIT], i.e. enough
    + * time has passed or enough results have arrived, then the interrupt is
    + * sent.
    + * * When CPT()_VQ()_DONE_ACK is written (or CPT()_VQ()_DONE is written
    + * but this is not typical), the interrupt coalescing timer restarts.
    + * Note after decrementing this interrupt equation is recomputed,
    + * for example if CPT()_VQ()_DONE[DONE] >= CPT()_VQ()_DONE_WAIT[NUM_WAIT]
    + * and because the timer is zero, the interrupt will be resent immediately.
    + * (This covers the race case between software acknowledging an interrupt
    + * and a result returning.)
    + * * When CPT()_VQ()_DONE_ENA_W1S[DONE] = 0, interrupts are not sent,
    + * but the counting described above still occurs.
    + * Since CPT instructions complete out-of-order, if software is using
    + * completion interrupts the suggested scheme is to request a DONEINT on
    + * each request, and when an interrupt arrives perform a "greedy" scan for
    + * completions; even if a later command is acknowledged first this will
    + * not result in missing a completion.
    + * Software is responsible for making sure [DONE] does not overflow;
    + * for example by insuring there are not more than 2^20-1 instructions in
    + * flight that may request interrupts.
    + *
    + */
    +union cptx_vqx_done {
    + u64 u;
    + struct cptx_vqx_done_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_20_63:44;
    + u64 done:20;
    +#else /* Word 0 - Little Endian */
    + u64 done:20;
    + u64 reserved_20_63:44;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_vq#_done_wait
    + *
    + * CPT Queue Done Interrupt Coalescing Wait Registers
    + * Specifies the per queue interrupt coalescing settings.
    + * cptx_vqx_done_wait_s
    + * Word0
    + * reserved_48_63:16 [63:48] Reserved.
    + * time_wait:16; [47:32](R/W) Time hold-off. When CPT()_VQ()_DONE[DONE] = 0
    + * or CPT()_VQ()_DONE_ACK is written a timer is cleared. When the timer
    + * reaches [TIME_WAIT]*1024 then interrupt coalescing ends.
    + * see CPT()_VQ()_DONE[DONE]. If 0x0, time coalescing is disabled.
    + * reserved_20_31:12 [31:20] Reserved.
    + * num_wait:20 [19:0](R/W) Number of messages hold-off.
    + * When CPT()_VQ()_DONE[DONE] >= [NUM_WAIT] then interrupt coalescing ends
    + * see CPT()_VQ()_DONE[DONE]. If 0x0, same behavior as 0x1.
    + *
    + */
    +union cptx_vqx_done_wait {
    + u64 u;
    + struct cptx_vqx_done_wait_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_48_63:16;
    + u64 time_wait:16;
    + u64 reserved_20_31:12;
    + u64 num_wait:20;
    +#else /* Word 0 - Little Endian */
    + u64 num_wait:20;
    + u64 reserved_20_31:12;
    + u64 time_wait:16;
    + u64 reserved_48_63:16;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_vq#_done_ena_w1s
    + *
    + * CPT Queue Done Interrupt Enable Set Registers
    + * Write 1 to these registers will enable the DONEINT interrupt for the queue.
    + * cptx_vqx_done_ena_w1s_s
    + * Word0
    + * reserved_1_63:63 [63:1] Reserved.
    + * done:1 [0:0](R/W1S/H) Write 1 will enable DONEINT for this queue.
    + * Write 0 has no effect. Read will return the enable bit.
    + */
    +union cptx_vqx_done_ena_w1s {
    + u64 u;
    + struct cptx_vqx_done_ena_w1s_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_1_63:63;
    + u64 done:1;
    +#else /* Word 0 - Little Endian */
    + u64 done:1;
    + u64 reserved_1_63:63;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +
    +/**
    + * Register (NCB) cpt#_vq#_ctl
    + *
    + * CPT VF Queue Control Registers
    + * This register configures queues. This register should be changed (other than
    + * clearing [ENA]) only when quiescent (see CPT()_VQ()_INPROG[INFLIGHT]).
    + * cptx_vqx_ctl_s
    + * Word0
    + * reserved_1_63:63 [63:1] Reserved.
    + * ena:1 [0:0](R/W/H) Enables the logical instruction queue.
    + * See also CPT()_PF_Q()_CTL[CONT_ERR] and CPT()_VQ()_INPROG[INFLIGHT].
    + * 1 = Queue is enabled.
    + * 0 = Queue is disabled.
    + */
    +union cptx_vqx_ctl {
    + u64 u;
    + struct cptx_vqx_ctl_s {
    +#if defined(__BIG_ENDIAN_BITFIELD) /* Word 0 - Big Endian */
    + u64 reserved_1_63:63;
    + u64 ena:1;
    +#else /* Word 0 - Little Endian */
    + u64 ena:1;
    + u64 reserved_1_63:63;
    +#endif /* Word 0 - End */
    + } s;
    +};
    +#endif /*__CPT_HW_TYPES_H*/
    diff --git a/drivers/crypto/cavium/cpt/cptpf.h b/drivers/crypto/cavium/cpt/cptpf.h
    new file mode 100644
    index 0000000..4511a21
    --- /dev/null
    +++ b/drivers/crypto/cavium/cpt/cptpf.h
    @@ -0,0 +1,69 @@
    +/*
    + * Copyright (C) 2016 Cavium, Inc.
    + *
    + * This program is free software; you can redistribute it and/or modify it
    + * under the terms of version 2 of the GNU General Public License
    + * as published by the Free Software Foundation.
    + */
    +
    +#ifndef __CPTPF_H
    +#define __CPTPF_H
    +
    +#include "cpt_common.h"
    +
    +#define CSR_DELAY 30
    +#define CPT_MAX_CORE_GROUPS 8
    +#define CPT_MAX_SE_CORES 10
    +#define CPT_MAX_AE_CORES 6
    +#define CPT_MAX_TOTAL_CORES (CPT_MAX_SE_CORES + CPT_MAX_AE_CORES)
    +#define CPT_MAX_VF_NUM 16
    +#define CPT_PF_MSIX_VECTORS 3
    +#define CPT_PF_INT_VEC_E_MBOXX(a) (0x02 + (a))
    +
    +struct cpt_device;
    +
    +struct microcode {
    + u8 is_mc_valid;
    + u8 is_ae;
    + u8 group;
    + u8 num_cores;
    + u32 code_size;
    + u64 core_mask;
    + u8 version[32];
    + /* Base info */
    + dma_addr_t phys_base;
    + void *code;
    +};
    +
    +struct cpt_vf_info {
    + u8 state;
    + u8 priority;
    + u8 id;
    + u32 qlen;
    +};
    +
    +/**
    + * cpt device structure
    + */
    +struct cpt_device {
    + u16 flags; /**< Flags to hold device status bits */
    + u8 num_vf_en; /**< Number of VFs enabled (0...CPT_MAX_VF_NUM) */
    + struct cpt_vf_info vfinfo[CPT_MAX_VF_NUM]; /* Per VF info */
    +
    + void __iomem *reg_base; /* Register start address */
    + /* MSI-X */
    + u8 num_vec;
    + bool msix_enabled;
    + struct msix_entry msix_entries[CPT_PF_MSIX_VECTORS];
    + bool irq_allocated[CPT_PF_MSIX_VECTORS];
    + struct pci_dev *pdev; /**< pci device handle */
    +
    + struct microcode mcode[CPT_MAX_CORE_GROUPS];
    + u8 next_mc_idx; /**< next microcode index */
    + u8 next_group;
    + u8 max_se_cores;
    + u8 max_ae_cores;
    +};
    +
    +void cpt_mbox_intr_handler(struct cpt_device *cpt, s32 mbx);
    +#endif /* __CPTPF_H */
    diff --git a/drivers/crypto/cavium/cpt/cptpf_main.c b/drivers/crypto/cavium/cpt/cptpf_main.c
    new file mode 100644
    index 0000000..ff6674b
    --- /dev/null
    +++ b/drivers/crypto/cavium/cpt/cptpf_main.c
    @@ -0,0 +1,733 @@
    +/*
    + * Copyright (C) 2016 Cavium, Inc.
    + *
    + * This program is free software; you can redistribute it and/or modify
    + * it under the terms of version 2 of the GNU General Public License
    + * as published by the Free Software Foundation.
    + */
    +
    +#include <linux/version.h>
    +#include <linux/module.h>
    +#include <linux/moduleparam.h>
    +#include <linux/printk.h>
    +#include <linux/device.h>
    +#include <linux/interrupt.h>
    +#include <linux/firmware.h>
    +#include <linux/pci.h>
    +
    +#include "cptpf.h"
    +
    +#define DRV_NAME "thunder-cpt"
    +#define DRV_VERSION "1.0"
    +
    +static u32 num_vfs = 4; /* Default 4 VF enabled */
    +module_param(num_vfs, uint, 0444);
    +MODULE_PARM_DESC(num_vfs, "Number of VFs to enable(1-16)");
    +
    +static u64 get_mask_from_value(s32 value)
    +{
    + u64 mask = 0ULL;
    + s32 i;
    +
    + for (i = 0; i < value; i++)
    + mask |= ((u64)1 << i);
    +
    + return mask;
    +}
    +
    +/*
    + * Disable cores specified by coremask
    + */
    +static void cpt_disable_cores(struct cpt_device *cpt, u64 coremask,
    + u8 type, u8 grp)
    +{
    + union cptx_pf_exe_ctl pf_exe_ctl;
    + u32 timeout = 0xFFFFFFFF;
    + u64 grpmask = 0;
    + struct device *dev = &cpt->pdev->dev;
    +
    + if (type == AE_TYPES)
    + coremask = (coremask << cpt->max_se_cores);
    +
    + /* Disengage the cores from groups */
    + grpmask = cpt_read_csr64(cpt->reg_base, CPTX_PF_GX_EN(0, grp));
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_GX_EN(0, grp),
    + (grpmask & ~coremask));
    + udelay(CSR_DELAY);
    + grp = cpt_read_csr64(cpt->reg_base, CPTX_PF_EXEC_BUSY(0));
    + while (grp & coremask) {
    + dev_err(dev, "Cores still busy %llx", coremask);
    + grp = cpt_read_csr64(cpt->reg_base,
    + CPTX_PF_EXEC_BUSY(0));
    + if (timeout--)
    + break;
    + }
    +
    + /* Disable the cores */
    + pf_exe_ctl.u = cpt_read_csr64(cpt->reg_base, CPTX_PF_EXE_CTL(0));
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_EXE_CTL(0),
    + (pf_exe_ctl.u & ~coremask));
    + udelay(CSR_DELAY);
    +}
    +
    +/*
    + * Enable cores specified by coremask
    + */
    +static void cpt_enable_cores(struct cpt_device *cpt, u64 coremask,
    + u8 type)
    +{
    + union cptx_pf_exe_ctl pf_exe_ctl;
    +
    + if (type == AE_TYPES)
    + coremask = (coremask << cpt->max_se_cores);
    +
    + pf_exe_ctl.u = cpt_read_csr64(cpt->reg_base, CPTX_PF_EXE_CTL(0));
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_EXE_CTL(0),
    + (pf_exe_ctl.u | coremask));
    + udelay(CSR_DELAY);
    +}
    +
    +static void cpt_configure_group(struct cpt_device *cpt, u8 grp,
    + u64 coremask, u8 type)
    +{
    + union cptx_pf_gx_en pf_gx_en = {0};
    +
    + if (type == AE_TYPES)
    + coremask = (coremask << cpt->max_se_cores);
    +
    + pf_gx_en.u = cpt_read_csr64(cpt->reg_base, CPTX_PF_GX_EN(0, grp));
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_GX_EN(0, grp),
    + (pf_gx_en.u | coremask));
    + udelay(CSR_DELAY);
    +}
    +
    +static void cpt_disable_mbox_interrupts(struct cpt_device *cpt)
    +{
    + /* Clear mbox(0) interupts for all vfs */
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_MBOX_ENA_W1CX(0, 0), ~0ull);
    +}
    +
    +static void cpt_disable_ecc_interrupts(struct cpt_device *cpt)
    +{
    + /* Clear ecc(0) interupts for all vfs */
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_ECC0_ENA_W1C(0), ~0ull);
    +}
    +
    +static void cpt_disable_exec_interrupts(struct cpt_device *cpt)
    +{
    + /* Clear exec interupts for all vfs */
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_EXEC_ENA_W1C(0), ~0ull);
    +}
    +
    +static void cpt_disable_all_interrupts(struct cpt_device *cpt)
    +{
    + cpt_disable_mbox_interrupts(cpt);
    + cpt_disable_ecc_interrupts(cpt);
    + cpt_disable_exec_interrupts(cpt);
    +}
    +
    +static void cpt_enable_mbox_interrupts(struct cpt_device *cpt)
    +{
    + /* Set mbox(0) interupts for all vfs */
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_MBOX_ENA_W1SX(0, 0), ~0ull);
    +}
    +
    +static s32 cpt_load_microcode(struct cpt_device *cpt, struct microcode *mcode)
    +{
    + s32 ret = 0, core = 0, shift = 0;
    + u32 total_cores = 0;
    + struct device *dev = &cpt->pdev->dev;
    +
    + if (!mcode || !mcode->code) {
    + dev_err(dev, "Either the mcode is null or data is NULL\n");
    + return 1;
    + }
    +
    + if (mcode->code_size == 0) {
    + dev_err(dev, "microcode size is 0\n");
    + return 1;
    + }
    +
    + /* Assumes 0-9 are SE cores for UCODE_BASE registers and
    + * AE core bases follow
    + */
    + if (mcode->is_ae) {
    + core = CPT_MAX_SE_CORES; /* start couting from 10 */
    + total_cores = CPT_MAX_TOTAL_CORES; /* upto 15 */
    + } else {
    + core = 0; /* start couting from 0 */
    + total_cores = CPT_MAX_SE_CORES; /* upto 9 */
    + }
    +
    + /* Point to microcode for each core of the group */
    + for (; core < total_cores ; core++, shift++) {
    + if (mcode->core_mask & (1 << shift)) {
    + cpt_write_csr64(cpt->reg_base,
    + CPTX_PF_ENGX_UCODE_BASE(0, core),
    + (u64)mcode->phys_base);
    + }
    + }
    + return ret;
    +}
    +
    +static s32 do_cpt_init(struct cpt_device *cpt, struct microcode *mcode)
    +{
    + s32 ret = 0;
    + struct device *dev = &cpt->pdev->dev;
    +
    + /* Make device not ready */
    + cpt->flags &= ~CPT_FLAG_DEVICE_READY;
    + /* Disable All PF interrupts */
    + cpt_disable_all_interrupts(cpt);
    + /* Calculate mcode group and coremasks */
    + if (mcode->is_ae) {
    + if (mcode->num_cores > cpt->max_ae_cores) {
    + dev_err(dev, "Requested for more cores than available AE cores\n");
    + ret = -1;
    + goto cpt_init_fail;
    + }
    +
    + if (cpt->next_group >= CPT_MAX_CORE_GROUPS) {
    + dev_err(dev, "Can't load, all eight microcode groups in use");
    + return -ENFILE;
    + }
    +
    + mcode->group = cpt->next_group;
    + /* Convert requested cores to mask */
    + mcode->core_mask = get_mask_from_value(mcode->num_cores);
    + cpt_disable_cores(cpt, mcode->core_mask, AE_TYPES,
    + mcode->group);
    + /* Load microcode for AE engines */
    + if (cpt_load_microcode(cpt, mcode)) {
    + dev_err(dev, "Microcode load Failed for %s\n",
    + mcode->version);
    + ret = -1;
    + goto cpt_init_fail;
    + }
    + cpt->next_group++;
    + /* Configure group mask for the mcode */
    + cpt_configure_group(cpt, mcode->group, mcode->core_mask,
    + AE_TYPES);
    + /* Enable AE cores for the group mask */
    + cpt_enable_cores(cpt, mcode->core_mask, AE_TYPES);
    + } else {
    + if (mcode->num_cores > cpt->max_se_cores) {
    + dev_err(dev, "Requested for more cores than available SE cores\n");
    + ret = -1;
    + goto cpt_init_fail;
    + }
    + if (cpt->next_group >= CPT_MAX_CORE_GROUPS) {
    + dev_err(dev, "Can't load, all eight microcode groups in use");
    + return -ENFILE;
    + }
    +
    + mcode->group = cpt->next_group;
    + /* Covert requested cores to mask */
    + mcode->core_mask = get_mask_from_value(mcode->num_cores);
    + cpt_disable_cores(cpt, mcode->core_mask, SE_TYPES,
    + mcode->group);
    + /* Load microcode for SE engines */
    + if (cpt_load_microcode(cpt, mcode)) {
    + dev_err(dev, "Microcode load Failed for %s\n",
    + mcode->version);
    + ret = -1;
    + goto cpt_init_fail;
    + }
    + cpt->next_group++;
    + /* Configure group mask for the mcode */
    + cpt_configure_group(cpt, mcode->group, mcode->core_mask,
    + SE_TYPES);
    + /* Enable SE cores for the group mask */
    + cpt_enable_cores(cpt, mcode->core_mask, SE_TYPES);
    + }
    +
    + /* Enabled PF mailbox interrupts */
    + cpt_enable_mbox_interrupts(cpt);
    + cpt->flags |= CPT_FLAG_DEVICE_READY;
    +
    + return ret;
    +
    +cpt_init_fail:
    + /* Enabled PF mailbox interrupts */
    + cpt_enable_mbox_interrupts(cpt);
    +
    + return ret;
    +}
    +
    +struct ucode_header {
    + u8 version[32];
    + u32 code_length;
    + u32 data_length;
    + u64 sram_address;
    +};
    +
    +static s32 cpt_ucode_load_fw(struct cpt_device *cpt, const u8 *fw, bool is_ae)
    +{
    + const struct firmware *fw_entry;
    + struct device *dev = &cpt->pdev->dev;
    + struct ucode_header *ucode;
    + struct microcode *mcode;
    + int j, ret = 0;
    +
    + ret = request_firmware(&fw_entry, fw, dev);
    + if (ret)
    + return ret;
    +
    + mcode = &cpt->mcode[cpt->next_mc_idx];
    + ucode = (struct ucode_header *)fw_entry->data;
    + memcpy(mcode->version, (u8 *)fw_entry->data, 32);
    + mcode->code_size = ntohl(ucode->code_length) * 2;
    + mcode->is_ae = is_ae;
    + mcode->core_mask = 0ULL;
    + mcode->num_cores = is_ae ? 6 : 10;
    +
    + /* Allocate DMAable space */
    + mcode->code = dma_zalloc_coherent(&cpt->pdev->dev, mcode->code_size,
    + &mcode->phys_base, GFP_KERNEL);
    + if (!mcode->code) {
    + dev_err(dev, "Unable to allocate space for microcode");
    + return -ENOMEM;
    + }
    +
    + memcpy((void *)mcode->code, (void *)(fw_entry->data + sizeof(*ucode)),
    + mcode->code_size);
    +
    + /* Byte swap 64-bit */
    + for (j = 0; j < (mcode->code_size / 8); j++)
    + ((u64 *)mcode->code)[j] = cpu_to_be64(((u64 *)mcode->code)[j]);
    + /* MC needs 16-bit swap */
    + for (j = 0; j < (mcode->code_size / 2); j++)
    + ((u16 *)mcode->code)[j] = cpu_to_be16(((u16 *)mcode->code)[j]);
    +
    + dev_dbg(dev, "mcode->code_size = %u\n", mcode->code_size);
    + dev_dbg(dev, "mcode->is_ae = %u\n", mcode->is_ae);
    + dev_dbg(dev, "mcode->num_cores = %u\n", mcode->num_cores);
    + dev_dbg(dev, "mcode->code = %llx\n", (u64)mcode->code);
    + dev_dbg(dev, "mcode->phys_base = %llx\n", mcode->phys_base);
    +
    + ret = do_cpt_init(cpt, mcode);
    + if (ret) {
    + dev_err(dev, "do_cpt_init failed with ret: %d\n", ret);
    + return ret;
    + }
    +
    + dev_info(dev, "Microcode Loaded %s\n", mcode->version);
    + mcode->is_mc_valid = 1;
    + cpt->next_mc_idx++;
    + release_firmware(fw_entry);
    +
    + return ret;
    +}
    +
    +static s32 cpt_ucode_load(struct cpt_device *cpt)
    +{
    + s32 ret = 0;
    + struct device *dev = &cpt->pdev->dev;
    +
    + ret = cpt_ucode_load_fw(cpt, "cpt8x-mc-ae.out", true);
    + if (ret) {
    + dev_err(dev, "ae:cpt_ucode_load failed with ret: %d\n", ret);
    + return ret;
    + }
    + ret = cpt_ucode_load_fw(cpt, "cpt8x-mc-se.out", false);
    + if (ret) {
    + dev_err(dev, "se:cpt_ucode_load failed with ret: %d\n", ret);
    + return ret;
    + }
    +
    + return ret;
    +}
    +
    +static s32 cpt_enable_msix(struct cpt_device *cpt)
    +{
    + s32 i, ret;
    +
    + cpt->num_vec = CPT_PF_MSIX_VECTORS;
    +
    + for (i = 0; i < cpt->num_vec; i++)
    + cpt->msix_entries[i].entry = i;
    +
    + ret = pci_enable_msix(cpt->pdev, cpt->msix_entries, cpt->num_vec);
    + if (ret) {
    + dev_err(&cpt->pdev->dev, "Request for #%d msix vectors failed\n",
    + cpt->num_vec);
    + return ret;
    + }
    +
    + cpt->msix_enabled = 1;
    + return 0;
    +}
    +
    +static irqreturn_t cpt_mbx0_intr_handler (s32 irq, void *cpt_irq)
    +{
    + struct cpt_device *cpt = (struct cpt_device *)cpt_irq;
    +
    + cpt_mbox_intr_handler(cpt, 0);
    +
    + return IRQ_HANDLED;
    +}
    +
    +static void cpt_disable_msix(struct cpt_device *cpt)
    +{
    + if (cpt->msix_enabled) {
    + pci_disable_msix(cpt->pdev);
    + cpt->msix_enabled = 0;
    + cpt->num_vec = 0;
    + }
    +}
    +
    +static void cpt_free_all_interrupts(struct cpt_device *cpt)
    +{
    + s32 irq;
    +
    + for (irq = 0; irq < cpt->num_vec; irq++) {
    + if (cpt->irq_allocated[irq])
    + free_irq(cpt->msix_entries[irq].vector, cpt);
    + cpt->irq_allocated[irq] = false;
    + }
    +}
    +
    +static void cpt_reset(struct cpt_device *cpt)
    +{
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_RESET(0), 1);
    +}
    +
    +static void cpt_find_max_enabled_cores(struct cpt_device *cpt)
    +{
    + union cptx_pf_constants pf_cnsts = {0};
    +
    + pf_cnsts.u = cpt_read_csr64(cpt->reg_base, CPTX_PF_CONSTANTS(0));
    + cpt->max_se_cores = pf_cnsts.s.se;
    + cpt->max_ae_cores = pf_cnsts.s.ae;
    +}
    +
    +static u32 cpt_check_bist_status(struct cpt_device *cpt)
    +{
    + union cptx_pf_bist_status bist_sts = {0};
    +
    + bist_sts.u = cpt_read_csr64(cpt->reg_base,
    + CPTX_PF_BIST_STATUS(0));
    +
    + return bist_sts.u;
    +}
    +
    +static u64 cpt_check_exe_bist_status(struct cpt_device *cpt)
    +{
    + union cptx_pf_exe_bist_status bist_sts = {0};
    +
    + bist_sts.u = cpt_read_csr64(cpt->reg_base,
    + CPTX_PF_EXE_BIST_STATUS(0));
    +
    + return bist_sts.u;
    +}
    +
    +static void cpt_disable_all_cores(struct cpt_device *cpt)
    +{
    + u32 grp, timeout = 0xFFFFFFFF;
    + struct device *dev = &cpt->pdev->dev;
    +
    + /* Disengage the cores from groups */
    + for (grp = 0; grp < CPT_MAX_CORE_GROUPS; grp++) {
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_GX_EN(0, grp), 0);
    + udelay(CSR_DELAY);
    + }
    +
    + grp = cpt_read_csr64(cpt->reg_base, CPTX_PF_EXEC_BUSY(0));
    + while (grp) {
    + dev_err(dev, "Cores still busy");
    + grp = cpt_read_csr64(cpt->reg_base,
    + CPTX_PF_EXEC_BUSY(0));
    + if (timeout--)
    + break;
    + }
    + /* Disable the cores */
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_EXE_CTL(0), 0);
    +}
    +
    +/**
    + * Ensure all cores are disenganed from all groups by
    + * calling cpt_disable_all_cores() before calling this
    + * function.
    + */
    +static void cpt_unload_microcode(struct cpt_device *cpt)
    +{
    + u32 grp = 0, core;
    +
    + /* Free microcode bases and reset group masks */
    + for (grp = 0; grp < CPT_MAX_CORE_GROUPS; grp++) {
    + struct microcode *mcode = &cpt->mcode[grp];
    +
    + if (cpt->mcode[grp].code)
    + dma_free_coherent(&cpt->pdev->dev, mcode->code_size,
    + mcode->code, mcode->phys_base);
    + mcode->code = NULL;
    + //mcode->base = NULL;
    + }
    + /* Clear UCODE_BASE registers for all engines */
    + for (core = 0; core < CPT_MAX_TOTAL_CORES; core++)
    + cpt_write_csr64(cpt->reg_base,
    + CPTX_PF_ENGX_UCODE_BASE(0, core), 0ull);
    +}
    +
    +static s32 cpt_device_init(struct cpt_device *cpt)
    +{
    + u64 bist;
    + struct device *dev = &cpt->pdev->dev;
    +
    + /* Reset the PF when probed first */
    + cpt_reset(cpt);
    + mdelay((100));
    +
    + /*Check BIST status*/
    + bist = (u64)cpt_check_bist_status(cpt);
    + if (bist) {
    + dev_err(dev, "RAM BIST failed with code 0x%llx", bist);
    + return -ENODEV;
    + }
    +
    + bist = cpt_check_exe_bist_status(cpt);
    + if (bist) {
    + dev_err(dev, "Engine BIST failed with code 0x%llx", bist);
    + return -ENODEV;
    + }
    +
    + /*Get CLK frequency*/
    + /*Get max enabled cores */
    + cpt_find_max_enabled_cores(cpt);
    + /*Disable all cores*/
    + cpt_disable_all_cores(cpt);
    + /*Reset device parameters*/
    + cpt->next_mc_idx = 0;
    + cpt->next_group = 0;
    + /* PF is ready */
    + cpt->flags |= CPT_FLAG_DEVICE_READY;
    +
    + return 0;
    +}
    +
    +static s32 cpt_register_interrupts(struct cpt_device *cpt)
    +{
    + s32 ret;
    + struct device *dev = &cpt->pdev->dev;
    +
    + /* Enable MSI-X */
    + ret = cpt_enable_msix(cpt);
    + if (ret)
    + return ret;
    +
    + /* Register mailbox interrupt handlers */
    + ret = request_irq(cpt->msix_entries[CPT_PF_INT_VEC_E_MBOXX(0)].vector,
    + cpt_mbx0_intr_handler, 0, "CPT Mbox0", cpt);
    + if (ret)
    + goto fail;
    +
    + cpt->irq_allocated[CPT_PF_INT_VEC_E_MBOXX(0)] = true;
    +
    + /* Enable mailbox interrupt */
    + cpt_enable_mbox_interrupts(cpt);
    + return 0;
    +
    +fail:
    + dev_err(dev, "Request irq failed\n");
    + cpt_free_all_interrupts(cpt);
    + return ret;
    +}
    +
    +static void cpt_unregister_interrupts(struct cpt_device *cpt)
    +{
    + cpt_free_all_interrupts(cpt);
    + cpt_disable_msix(cpt);
    +}
    +
    +static s32 cpt_sriov_init(struct cpt_device *cpt, s32 num_vfs)
    +{
    + s32 pos = 0;
    + s32 err;
    + u16 total_vf_cnt;
    + struct pci_dev *pdev = cpt->pdev;
    +
    + pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_SRIOV);
    + if (!pos) {
    + dev_err(&pdev->dev, "SRIOV capability is not found in PCIe config space\n");
    + return -ENODEV;
    + }
    +
    + cpt->num_vf_en = num_vfs; /* User requested VFs */
    + pci_read_config_word(pdev, (pos + PCI_SRIOV_TOTAL_VF), &total_vf_cnt);
    + if (total_vf_cnt < cpt->num_vf_en)
    + cpt->num_vf_en = total_vf_cnt;
    +
    + if (!total_vf_cnt)
    + return 0;
    +
    + /*Enabled the available VFs */
    + err = pci_enable_sriov(pdev, cpt->num_vf_en);
    + if (err) {
    + dev_err(&pdev->dev, "SRIOV enable failed, num VF is %d\n",
    + cpt->num_vf_en);
    + cpt->num_vf_en = 0;
    + return err;
    + }
    +
    + /* TODO: Optionally enable static VQ priorities feature */
    +
    + dev_info(&pdev->dev, "SRIOV enabled, number of VF available %d\n",
    + cpt->num_vf_en);
    +
    + cpt->flags |= CPT_FLAG_SRIOV_ENABLED;
    +
    + return 0;
    +}
    +
    +static s32 cpt_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
    +{
    + struct device *dev = &pdev->dev;
    + struct cpt_device *cpt;
    + s32 err;
    +
    + cpt = devm_kzalloc(dev, sizeof(struct cpt_device), GFP_KERNEL);
    + if (!cpt)
    + return -ENOMEM;
    +
    + pci_set_drvdata(pdev, cpt);
    + cpt->pdev = pdev;
    + err = pci_enable_device(pdev);
    + if (err) {
    + dev_err(dev, "Failed to enable PCI device\n");
    + pci_set_drvdata(pdev, NULL);
    + return err;
    + }
    +
    + err = pci_request_regions(pdev, DRV_NAME);
    + if (err) {
    + dev_err(dev, "PCI request regions failed 0x%x\n", err);
    + goto cpt_err_disable_device;
    + }
    +
    + err = pci_set_dma_mask(pdev, DMA_BIT_MASK(48));
    + if (err) {
    + dev_err(dev, "Unable to get usable DMA configuration\n");
    + goto cpt_err_release_regions;
    + }
    +
    + err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(48));
    + if (err) {
    + dev_err(dev, "Unable to get 48-bit DMA for consistent allocations\n");
    + goto cpt_err_release_regions;
    + }
    +
    + /* MAP PF's configuration registers */
    + cpt->reg_base = pcim_iomap(pdev, 0, 0);
    + if (!cpt->reg_base) {
    + dev_err(dev, "Cannot map config register space, aborting\n");
    + err = -ENOMEM;
    + goto cpt_err_release_regions;
    + }
    +
    + /* CPT device HW initialization */
    + cpt_device_init(cpt);
    +
    + /* Register interrupts */
    + err = cpt_register_interrupts(cpt);
    + if (err)
    + goto cpt_err_release_regions;
    +
    + err = cpt_ucode_load(cpt);
    + if (err)
    + goto cpt_err_unregister_interrupts;
    +
    + /* Configure SRIOV */
    + err = cpt_sriov_init(cpt, num_vfs);
    + if (err)
    + goto cpt_err_unregister_interrupts;
    +
    + return 0;
    +
    +cpt_err_unregister_interrupts:
    + cpt_unregister_interrupts(cpt);
    +cpt_err_release_regions:
    + pci_release_regions(pdev);
    +cpt_err_disable_device:
    + pci_disable_device(pdev);
    + pci_set_drvdata(pdev, NULL);
    + return err;
    +}
    +
    +static void cpt_remove(struct pci_dev *pdev)
    +{
    + struct cpt_device *cpt = pci_get_drvdata(pdev);
    +
    + /* Disengage SE and AE cores from all groups*/
    + cpt_disable_all_cores(cpt);
    + /* Unload microcodes */
    + cpt_unload_microcode(cpt);
    + cpt_unregister_interrupts(cpt);
    + pci_disable_sriov(pdev);
    + pci_release_regions(pdev);
    + pci_disable_device(pdev);
    + pci_set_drvdata(pdev, NULL);
    +}
    +
    +static void cpt_shutdown(struct pci_dev *pdev)
    +{
    + struct cpt_device *cpt = pci_get_drvdata(pdev);
    +
    + if (!cpt)
    + return;
    +
    + dev_info(&pdev->dev, "Shutdown device %x:%x.\n",
    + (u32)pdev->vendor, (u32)pdev->device);
    +
    + cpt_unregister_interrupts(cpt);
    + pci_release_regions(pdev);
    + pci_disable_device(pdev);
    + pci_set_drvdata(pdev, NULL);
    + kzfree(cpt);
    +}
    +
    +/* Supported devices */
    +static const struct pci_device_id cpt_id_table[] = {
    + { PCI_DEVICE(PCI_VENDOR_ID_CAVIUM, CPT_81XX_PCI_PF_DEVICE_ID) },
    + { 0, } /* end of table */
    +};
    +
    +static struct pci_driver cpt_pci_driver = {
    + .name = DRV_NAME,
    + .id_table = cpt_id_table,
    + .probe = cpt_probe,
    + .remove = cpt_remove,
    + .shutdown = cpt_shutdown,
    +};
    +
    +static s32 __init cpt_init_module(void)
    +{
    + s32 ret = -1;
    +
    + pr_info("%s, ver %s\n", DRV_NAME, DRV_VERSION);
    +
    + if (num_vfs > 16) {
    + pr_warn("Invalid vf count %d, Resetting it to 1(default)\n",
    + num_vfs);
    + num_vfs = 4;
    + }
    +
    + ret = pci_register_driver(&cpt_pci_driver);
    + if (ret)
    + pr_err("pci_register_driver() failed");
    +
    + return ret;
    +}
    +
    +static void __exit cpt_cleanup_module(void)
    +{
    + pci_unregister_driver(&cpt_pci_driver);
    +}
    +
    +module_init(cpt_init_module);
    +module_exit(cpt_cleanup_module);
    +
    +MODULE_AUTHOR("George Cherian <george.cherian@cavium.com>");
    +MODULE_DESCRIPTION("Cavium Thunder CPT Physical Function Driver");
    +MODULE_LICENSE("GPL v2");
    +MODULE_VERSION(DRV_VERSION);
    +MODULE_DEVICE_TABLE(pci, cpt_id_table);
    diff --git a/drivers/crypto/cavium/cpt/cptpf_mbox.c b/drivers/crypto/cavium/cpt/cptpf_mbox.c
    new file mode 100644
    index 0000000..1039a5f
    --- /dev/null
    +++ b/drivers/crypto/cavium/cpt/cptpf_mbox.c
    @@ -0,0 +1,163 @@
    +/*
    + * Copyright (C) 2016 Cavium, Inc.
    + *
    + * This program is free software; you can redistribute it and/or modify
    + * it under the terms of version 2 of the GNU General Public License
    + * as published by the Free Software Foundation.
    + */
    +#include <linux/module.h>
    +#include "cptpf.h"
    +
    +static void cpt_send_msg_to_vf(struct cpt_device *cpt, s32 vf,
    + struct cpt_mbox *mbx)
    +{
    + /* Writing mbox(0) causes interrupt */
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_VFX_MBOXX(0, vf, 1),
    + mbx->data);
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_VFX_MBOXX(0, vf, 0), mbx->msg);
    +}
    +
    +/* ACKs VF's mailbox message
    + * @vf: VF to which ACK to be sent
    + */
    +static void cpt_mbox_send_ack(struct cpt_device *cpt, s32 vf,
    + struct cpt_mbox *mbx)
    +{
    + mbx->data = 0ull;
    + mbx->msg = CPT_MBOX_MSG_TYPE_ACK;
    + cpt_send_msg_to_vf(cpt, vf, mbx);
    +}
    +
    +static void cpt_clear_mbox_intr(struct cpt_device *cpt, u32 vf)
    +{
    + /* W1C for the VF */
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_MBOX_INTX(0, 0), (1 << vf));
    +}
    +
    +/*
    + * Configure QLEN/Chunk sizes for VF
    + */
    +static void cpt_cfg_qlen_for_vf(struct cpt_device *cpt, s32 vf, u32 size)
    +{
    + union cptx_pf_qx_ctl pf_qx_ctl;
    +
    + pf_qx_ctl.u = cpt_read_csr64(cpt->reg_base, CPTX_PF_QX_CTL(0, vf));
    + pf_qx_ctl.s.size = size;
    + pf_qx_ctl.s.cont_err = true;
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_QX_CTL(0, vf), pf_qx_ctl.u);
    +}
    +
    +/*
    + * Configure VQ priority
    + */
    +static void cpt_cfg_vq_priority(struct cpt_device *cpt, s32 vf, u32 pri)
    +{
    + union cptx_pf_qx_ctl pf_qx_ctl;
    +
    + pf_qx_ctl.u = cpt_read_csr64(cpt->reg_base, CPTX_PF_QX_CTL(0, vf));
    + pf_qx_ctl.s.pri = pri;
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_QX_CTL(0, vf), pf_qx_ctl.u);
    +}
    +
    +static u8 cpt_bind_vq_to_grp(struct cpt_device *cpt, u8 q, u8 grp)
    +{
    + struct microcode *mcode = cpt->mcode;
    + union cptx_pf_qx_ctl pf_qx_ctl;
    + struct device *dev = &cpt->pdev->dev;
    +
    + if (q >= CPT_MAX_VF_NUM) {
    + dev_err(dev, "Queues are more than cores in the group");
    + return -EINVAL;
    + }
    + if (grp >= CPT_MAX_CORE_GROUPS) {
    + dev_err(dev, "Request group is more than possible groups");
    + return -EINVAL;
    + }
    + if (grp >= cpt->next_mc_idx) {
    + dev_err(dev, "Request group is higher than available functional groups");
    + return -EINVAL;
    + }
    + pf_qx_ctl.u = cpt_read_csr64(cpt->reg_base, CPTX_PF_QX_CTL(0, q));
    + pf_qx_ctl.s.grp = mcode[grp].group;
    + cpt_write_csr64(cpt->reg_base, CPTX_PF_QX_CTL(0, q), pf_qx_ctl.u);
    + dev_dbg(dev, "VF %d TYPE %s", q, (mcode[grp].is_ae ? "AE" : "SE"));
    +
    + return mcode[grp].is_ae ? AE_TYPES : SE_TYPES;
    +}
    +
    +/* Interrupt handler to handle mailbox messages from VFs */
    +static void cpt_handle_mbox_intr(struct cpt_device *cpt, s32 vf)
    +{
    + struct cpt_vf_info *vfx = &cpt->vfinfo[vf];
    + struct cpt_mbox mbx = {};
    + u8 vftype;
    + struct device *dev = &cpt->pdev->dev;
    + /*
    + * MBOX[0] contains msg
    + * MBOX[1] contains data
    + */
    + mbx.msg = cpt_read_csr64(cpt->reg_base, CPTX_PF_VFX_MBOXX(0, vf, 0));
    + mbx.data = cpt_read_csr64(cpt->reg_base, CPTX_PF_VFX_MBOXX(0, vf, 1));
    + dev_dbg(dev, "%s: Mailbox msg 0x%llx from VF%d", __func__, mbx.msg, vf);
    + switch (mbx.msg) {
    + case CPT_MSG_VF_UP:
    + vfx->state = VF_STATE_UP;
    + try_module_get(THIS_MODULE);
    + cpt_mbox_send_ack(cpt, vf, &mbx);
    + break;
    + case CPT_MSG_READY:
    + mbx.msg = CPT_MSG_READY;
    + mbx.data = vf;
    + cpt_send_msg_to_vf(cpt, vf, &mbx);
    + break;
    + case CPT_MSG_VF_DOWN:
    + /* First msg in VF teardown sequence */
    + vfx->state = VF_STATE_DOWN;
    + module_put(THIS_MODULE);
    + cpt_mbox_send_ack(cpt, vf, &mbx);
    + break;
    + case CPT_MSG_QLEN:
    + vfx->qlen = mbx.data;
    + cpt_cfg_qlen_for_vf(cpt, vf, vfx->qlen);
    + cpt_mbox_send_ack(cpt, vf, &mbx);
    + break;
    + case CPT_MSG_QBIND_GRP:
    + vftype = cpt_bind_vq_to_grp(cpt, vf, (u8)mbx.data);
    + if ((vftype != AE_TYPES) && (vftype != SE_TYPES))
    + dev_err(dev, "Queue %d binding to group %llu failed",
    + vf, mbx.data);
    + else {
    + dev_dbg(dev, "Queue %d binding to group %llu successful",
    + vf, mbx.data);
    + mbx.msg = CPT_MSG_QBIND_GRP;
    + mbx.data = vftype;
    + cpt_send_msg_to_vf(cpt, vf, &mbx);
    + }
    + break;
    + case CPT_MSG_VQ_PRIORITY:
    + vfx->priority = mbx.data;
    + cpt_cfg_vq_priority(cpt, vf, vfx->priority);
    + cpt_mbox_send_ack(cpt, vf, &mbx);
    + break;
    + default:
    + dev_err(&cpt->pdev->dev, "Invalid msg from VF%d, msg 0x%llx\n",
    + vf, mbx.msg);
    + break;
    + }
    +}
    +
    +void cpt_mbox_intr_handler (struct cpt_device *cpt, s32 mbx)
    +{
    + u64 intr;
    + u8 vf;
    +
    + intr = cpt_read_csr64(cpt->reg_base, CPTX_PF_MBOX_INTX(0, 0));
    + dev_dbg(&cpt->pdev->dev, "PF interrupt Mbox%d 0x%llx\n", mbx, intr);
    + for (vf = 0; vf < CPT_MAX_VF_NUM; vf++) {
    + if (intr & (1ULL << vf)) {
    + dev_dbg(&cpt->pdev->dev, "Intr from VF %d\n", vf);
    + cpt_handle_mbox_intr(cpt, vf);
    + cpt_clear_mbox_intr(cpt, vf);
    + }
    + }
    +}
    --
    2.1.4
    \
     
     \ /
      Last update: 2016-12-13 16:38    [W:3.470 / U:0.024 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site