crypto: mediatek - remove obsolete driver (6a702fa5) · Commits · jan.koester / Linux

drivers/crypto/Kconfig

+0 −15

Original line number	Diff line number	Diff line
		@@ -772,21 +772,6 @@ config CRYPTO_DEV_ZYNQMP_AES
		accelerator. Select this if you want to use the ZynqMP module
		for AES algorithms.

		config CRYPTO_DEV_MEDIATEK
		tristate "MediaTek's EIP97 Cryptographic Engine driver"
		depends on (ARM && ARCH_MEDIATEK) \|\| COMPILE_TEST
		select CRYPTO_LIB_AES
		select CRYPTO_AEAD
		select CRYPTO_SKCIPHER
		select CRYPTO_SHA1
		select CRYPTO_SHA256
		select CRYPTO_SHA512
		select CRYPTO_HMAC
		help
		This driver allows you to utilize the hardware crypto accelerator
		EIP97 which can be found on the MT7623 MT2701, MT8521p, etc ....
		Select this if you want to use it for AES/SHA1/SHA2 algorithms.

		source "drivers/crypto/chelsio/Kconfig"

		source "drivers/crypto/virtio/Kconfig"

drivers/crypto/Makefile

+0 −1

Original line number	Diff line number	Diff line
		@@ -19,7 +19,6 @@ obj-$(CONFIG_CRYPTO_DEV_HIFN_795X) += hifn_795x.o
		obj-$(CONFIG_CRYPTO_DEV_IMGTEC_HASH) += img-hash.o
		obj-$(CONFIG_CRYPTO_DEV_IXP4XX) += ixp4xx_crypto.o
		obj-$(CONFIG_CRYPTO_DEV_MARVELL) += marvell/
		obj-$(CONFIG_CRYPTO_DEV_MEDIATEK) += mediatek/
		obj-$(CONFIG_CRYPTO_DEV_MXS_DCP) += mxs-dcp.o
		obj-$(CONFIG_CRYPTO_DEV_NIAGARA2) += n2_crypto.o
		n2_crypto-y := n2_core.o n2_asm.o

drivers/crypto/mediatek/Makefile

deleted100644 → 0

+0 −3

Original line number	Diff line number	Diff line
		# SPDX-License-Identifier: GPL-2.0-only
		obj-$(CONFIG_CRYPTO_DEV_MEDIATEK) += mtk-crypto.o
		mtk-crypto-objs:= mtk-platform.o mtk-aes.o mtk-sha.o

drivers/crypto/mediatek/mtk-aes.c

deleted100644 → 0

+0 −1271

File deleted.

Preview size limit exceeded, changes collapsed.

drivers/crypto/mediatek/mtk-platform.c

deleted100644 → 0

+0 −586

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-only
		/*
		* Driver for EIP97 cryptographic accelerator.
		*
		* Copyright (c) 2016 Ryder Lee <ryder.lee@mediatek.com>
		*/

		#include <linux/clk.h>
		#include <linux/init.h>
		#include <linux/kernel.h>
		#include <linux/module.h>
		#include <linux/mod_devicetable.h>
		#include <linux/platform_device.h>
		#include <linux/pm_runtime.h>
		#include "mtk-platform.h"

		#define MTK_BURST_SIZE_MSK GENMASK(7, 4)
		#define MTK_BURST_SIZE(x) ((x) << 4)
		#define MTK_DESC_SIZE(x) ((x) << 0)
		#define MTK_DESC_OFFSET(x) ((x) << 16)
		#define MTK_DESC_FETCH_SIZE(x) ((x) << 0)
		#define MTK_DESC_FETCH_THRESH(x) ((x) << 16)
		#define MTK_DESC_OVL_IRQ_EN BIT(25)
		#define MTK_DESC_ATP_PRESENT BIT(30)

		#define MTK_DFSE_IDLE GENMASK(3, 0)
		#define MTK_DFSE_THR_CTRL_EN BIT(30)
		#define MTK_DFSE_THR_CTRL_RESET BIT(31)
		#define MTK_DFSE_RING_ID(x) (((x) >> 12) & GENMASK(3, 0))
		#define MTK_DFSE_MIN_DATA(x) ((x) << 0)
		#define MTK_DFSE_MAX_DATA(x) ((x) << 8)
		#define MTK_DFE_MIN_CTRL(x) ((x) << 16)
		#define MTK_DFE_MAX_CTRL(x) ((x) << 24)

		#define MTK_IN_BUF_MIN_THRESH(x) ((x) << 8)
		#define MTK_IN_BUF_MAX_THRESH(x) ((x) << 12)
		#define MTK_OUT_BUF_MIN_THRESH(x) ((x) << 0)
		#define MTK_OUT_BUF_MAX_THRESH(x) ((x) << 4)
		#define MTK_IN_TBUF_SIZE(x) (((x) >> 4) & GENMASK(3, 0))
		#define MTK_IN_DBUF_SIZE(x) (((x) >> 8) & GENMASK(3, 0))
		#define MTK_OUT_DBUF_SIZE(x) (((x) >> 16) & GENMASK(3, 0))
		#define MTK_CMD_FIFO_SIZE(x) (((x) >> 8) & GENMASK(3, 0))
		#define MTK_RES_FIFO_SIZE(x) (((x) >> 12) & GENMASK(3, 0))

		#define MTK_PE_TK_LOC_AVL BIT(2)
		#define MTK_PE_PROC_HELD BIT(14)
		#define MTK_PE_TK_TIMEOUT_EN BIT(22)
		#define MTK_PE_INPUT_DMA_ERR BIT(0)
		#define MTK_PE_OUTPUT_DMA_ERR BIT(1)
		#define MTK_PE_PKT_PORC_ERR BIT(2)
		#define MTK_PE_PKT_TIMEOUT BIT(3)
		#define MTK_PE_FATAL_ERR BIT(14)
		#define MTK_PE_INPUT_DMA_ERR_EN BIT(16)
		#define MTK_PE_OUTPUT_DMA_ERR_EN BIT(17)
		#define MTK_PE_PKT_PORC_ERR_EN BIT(18)
		#define MTK_PE_PKT_TIMEOUT_EN BIT(19)
		#define MTK_PE_FATAL_ERR_EN BIT(30)
		#define MTK_PE_INT_OUT_EN BIT(31)

		#define MTK_HIA_SIGNATURE ((u16)0x35ca)
		#define MTK_HIA_DATA_WIDTH(x) (((x) >> 25) & GENMASK(1, 0))
		#define MTK_HIA_DMA_LENGTH(x) (((x) >> 20) & GENMASK(4, 0))
		#define MTK_CDR_STAT_CLR GENMASK(4, 0)
		#define MTK_RDR_STAT_CLR GENMASK(7, 0)

		#define MTK_AIC_INT_MSK GENMASK(5, 0)
		#define MTK_AIC_VER_MSK (GENMASK(15, 0) \| GENMASK(27, 20))
		#define MTK_AIC_VER11 0x011036c9
		#define MTK_AIC_VER12 0x012036c9
		#define MTK_AIC_G_CLR GENMASK(30, 20)

		/**
		* EIP97 is an integrated security subsystem to accelerate cryptographic
		* functions and protocols to offload the host processor.
		* Some important hardware modules are briefly introduced below:
		*
		* Host Interface Adapter(HIA) - the main interface between the host
		* system and the hardware subsystem. It is responsible for attaching
		* processing engine to the specific host bus interface and provides a
		* standardized software view for off loading tasks to the engine.
		*
		* Command Descriptor Ring Manager(CDR Manager) - keeps track of how many
		* CD the host has prepared in the CDR. It monitors the fill level of its
		* CD-FIFO and if there's sufficient space for the next block of descriptors,
		* then it fires off a DMA request to fetch a block of CDs.
		*
		* Data fetch engine(DFE) - It is responsible for parsing the CD and
		* setting up the required control and packet data DMA transfers from
		* system memory to the processing engine.
		*
		* Result Descriptor Ring Manager(RDR Manager) - same as CDR Manager,
		* but target is result descriptors, Moreover, it also handles the RD
		* updates under control of the DSE. For each packet data segment
		* processed, the DSE triggers the RDR Manager to write the updated RD.
		* If triggered to update, the RDR Manager sets up a DMA operation to
		* copy the RD from the DSE to the correct location in the RDR.
		*
		* Data Store Engine(DSE) - It is responsible for parsing the prepared RD
		* and setting up the required control and packet data DMA transfers from
		* the processing engine to system memory.
		*
		* Advanced Interrupt Controllers(AICs) - receive interrupt request signals
		* from various sources and combine them into one interrupt output.
		* The AICs are used by:
		* - One for the HIA global and processing engine interrupts.
		* - The others for the descriptor ring interrupts.
		*/

		/* Cryptographic engine capabilities */
		struct mtk_sys_cap {
		/* host interface adapter */
		u32 hia_ver;
		u32 hia_opt;
		/* packet engine */
		u32 pkt_eng_opt;
		/* global hardware */
		u32 hw_opt;
		};

		static void mtk_desc_ring_link(struct mtk_cryp *cryp, u32 mask)
		{
		/* Assign rings to DFE/DSE thread and enable it */
		writel(MTK_DFSE_THR_CTRL_EN \| mask, cryp->base + DFE_THR_CTRL);
		writel(MTK_DFSE_THR_CTRL_EN \| mask, cryp->base + DSE_THR_CTRL);
		}

		static void mtk_dfe_dse_buf_setup(struct mtk_cryp *cryp,
		struct mtk_sys_cap *cap)
		{
		u32 width = MTK_HIA_DATA_WIDTH(cap->hia_opt) + 2;
		u32 len = MTK_HIA_DMA_LENGTH(cap->hia_opt) - 1;
		u32 ipbuf = min((u32)MTK_IN_DBUF_SIZE(cap->hw_opt) + width, len);
		u32 opbuf = min((u32)MTK_OUT_DBUF_SIZE(cap->hw_opt) + width, len);
		u32 itbuf = min((u32)MTK_IN_TBUF_SIZE(cap->hw_opt) + width, len);

		writel(MTK_DFSE_MIN_DATA(ipbuf - 1) \|
		MTK_DFSE_MAX_DATA(ipbuf) \|
		MTK_DFE_MIN_CTRL(itbuf - 1) \|
		MTK_DFE_MAX_CTRL(itbuf),
		cryp->base + DFE_CFG);

		writel(MTK_DFSE_MIN_DATA(opbuf - 1) \|
		MTK_DFSE_MAX_DATA(opbuf),
		cryp->base + DSE_CFG);

		writel(MTK_IN_BUF_MIN_THRESH(ipbuf - 1) \|
		MTK_IN_BUF_MAX_THRESH(ipbuf),
		cryp->base + PE_IN_DBUF_THRESH);

		writel(MTK_IN_BUF_MIN_THRESH(itbuf - 1) \|
		MTK_IN_BUF_MAX_THRESH(itbuf),
		cryp->base + PE_IN_TBUF_THRESH);

		writel(MTK_OUT_BUF_MIN_THRESH(opbuf - 1) \|
		MTK_OUT_BUF_MAX_THRESH(opbuf),
		cryp->base + PE_OUT_DBUF_THRESH);

		writel(0, cryp->base + PE_OUT_TBUF_THRESH);
		writel(0, cryp->base + PE_OUT_BUF_CTRL);
		}

		static int mtk_dfe_dse_state_check(struct mtk_cryp *cryp)
		{
		int ret = -EINVAL;
		u32 val;

		/* Check for completion of all DMA transfers */
		val = readl(cryp->base + DFE_THR_STAT);
		if (MTK_DFSE_RING_ID(val) == MTK_DFSE_IDLE) {
		val = readl(cryp->base + DSE_THR_STAT);
		if (MTK_DFSE_RING_ID(val) == MTK_DFSE_IDLE)
		ret = 0;
		}

		if (!ret) {
		/* Take DFE/DSE thread out of reset */
		writel(0, cryp->base + DFE_THR_CTRL);
		writel(0, cryp->base + DSE_THR_CTRL);
		} else {
		return -EBUSY;
		}

		return 0;
		}

		static int mtk_dfe_dse_reset(struct mtk_cryp *cryp)
		{
		/* Reset DSE/DFE and correct system priorities for all rings. */
		writel(MTK_DFSE_THR_CTRL_RESET, cryp->base + DFE_THR_CTRL);
		writel(0, cryp->base + DFE_PRIO_0);
		writel(0, cryp->base + DFE_PRIO_1);
		writel(0, cryp->base + DFE_PRIO_2);
		writel(0, cryp->base + DFE_PRIO_3);

		writel(MTK_DFSE_THR_CTRL_RESET, cryp->base + DSE_THR_CTRL);
		writel(0, cryp->base + DSE_PRIO_0);
		writel(0, cryp->base + DSE_PRIO_1);
		writel(0, cryp->base + DSE_PRIO_2);
		writel(0, cryp->base + DSE_PRIO_3);

		return mtk_dfe_dse_state_check(cryp);
		}

		static void mtk_cmd_desc_ring_setup(struct mtk_cryp *cryp,
		int i, struct mtk_sys_cap *cap)
		{
		/* Full descriptor that fits FIFO minus one */
		u32 count =
		((1 << MTK_CMD_FIFO_SIZE(cap->hia_opt)) / MTK_DESC_SZ) - 1;

		/* Temporarily disable external triggering */
		writel(0, cryp->base + CDR_CFG(i));

		/* Clear CDR count */
		writel(MTK_CNT_RST, cryp->base + CDR_PREP_COUNT(i));
		writel(MTK_CNT_RST, cryp->base + CDR_PROC_COUNT(i));

		writel(0, cryp->base + CDR_PREP_PNTR(i));
		writel(0, cryp->base + CDR_PROC_PNTR(i));
		writel(0, cryp->base + CDR_DMA_CFG(i));

		/* Configure CDR host address space */
		writel(0, cryp->base + CDR_BASE_ADDR_HI(i));
		writel(cryp->ring[i]->cmd_dma, cryp->base + CDR_BASE_ADDR_LO(i));

		writel(MTK_DESC_RING_SZ, cryp->base + CDR_RING_SIZE(i));

		/* Clear and disable all CDR interrupts */
		writel(MTK_CDR_STAT_CLR, cryp->base + CDR_STAT(i));

		/*
		* Set command descriptor offset and enable additional
		* token present in descriptor.
		*/
		writel(MTK_DESC_SIZE(MTK_DESC_SZ) \|
		MTK_DESC_OFFSET(MTK_DESC_OFF) \|
		MTK_DESC_ATP_PRESENT,
		cryp->base + CDR_DESC_SIZE(i));

		writel(MTK_DESC_FETCH_SIZE(count * MTK_DESC_OFF) \|
		MTK_DESC_FETCH_THRESH(count * MTK_DESC_SZ),
		cryp->base + CDR_CFG(i));
		}

		static void mtk_res_desc_ring_setup(struct mtk_cryp *cryp,
		int i, struct mtk_sys_cap *cap)
		{
		u32 rndup = 2;
		u32 count = ((1 << MTK_RES_FIFO_SIZE(cap->hia_opt)) / rndup) - 1;

		/* Temporarily disable external triggering */
		writel(0, cryp->base + RDR_CFG(i));

		/* Clear RDR count */
		writel(MTK_CNT_RST, cryp->base + RDR_PREP_COUNT(i));
		writel(MTK_CNT_RST, cryp->base + RDR_PROC_COUNT(i));

		writel(0, cryp->base + RDR_PREP_PNTR(i));
		writel(0, cryp->base + RDR_PROC_PNTR(i));
		writel(0, cryp->base + RDR_DMA_CFG(i));

		/* Configure RDR host address space */
		writel(0, cryp->base + RDR_BASE_ADDR_HI(i));
		writel(cryp->ring[i]->res_dma, cryp->base + RDR_BASE_ADDR_LO(i));

		writel(MTK_DESC_RING_SZ, cryp->base + RDR_RING_SIZE(i));
		writel(MTK_RDR_STAT_CLR, cryp->base + RDR_STAT(i));

		/*
		* RDR manager generates update interrupts on a per-completed-packet,
		* and the rd_proc_thresh_irq interrupt is fired when proc_pkt_count
		* for the RDR exceeds the number of packets.
		*/
		writel(MTK_RDR_PROC_THRESH \| MTK_RDR_PROC_MODE,
		cryp->base + RDR_THRESH(i));

		/*
		* Configure a threshold and time-out value for the processed
		* result descriptors (or complete packets) that are written to
		* the RDR.
		*/
		writel(MTK_DESC_SIZE(MTK_DESC_SZ) \| MTK_DESC_OFFSET(MTK_DESC_OFF),
		cryp->base + RDR_DESC_SIZE(i));

		/*
		* Configure HIA fetch size and fetch threshold that are used to
		* fetch blocks of multiple descriptors.
		*/
		writel(MTK_DESC_FETCH_SIZE(count * MTK_DESC_OFF) \|
		MTK_DESC_FETCH_THRESH(count * rndup) \|
		MTK_DESC_OVL_IRQ_EN,
		cryp->base + RDR_CFG(i));
		}

		static int mtk_packet_engine_setup(struct mtk_cryp *cryp)
		{
		struct mtk_sys_cap cap;
		int i, err;
		u32 val;

		cap.hia_ver = readl(cryp->base + HIA_VERSION);
		cap.hia_opt = readl(cryp->base + HIA_OPTIONS);
		cap.hw_opt = readl(cryp->base + EIP97_OPTIONS);

		if (!(((u16)cap.hia_ver) == MTK_HIA_SIGNATURE))
		return -EINVAL;

		/* Configure endianness conversion method for master (DMA) interface */
		writel(0, cryp->base + EIP97_MST_CTRL);

		/* Set HIA burst size */
		val = readl(cryp->base + HIA_MST_CTRL);
		val &= ~MTK_BURST_SIZE_MSK;
		val \|= MTK_BURST_SIZE(5);
		writel(val, cryp->base + HIA_MST_CTRL);

		err = mtk_dfe_dse_reset(cryp);
		if (err) {
		dev_err(cryp->dev, "Failed to reset DFE and DSE.\n");
		return err;
		}

		mtk_dfe_dse_buf_setup(cryp, &cap);

		/* Enable the 4 rings for the packet engines. */
		mtk_desc_ring_link(cryp, 0xf);

		for (i = 0; i < MTK_RING_MAX; i++) {
		mtk_cmd_desc_ring_setup(cryp, i, &cap);
		mtk_res_desc_ring_setup(cryp, i, &cap);
		}

		writel(MTK_PE_TK_LOC_AVL \| MTK_PE_PROC_HELD \| MTK_PE_TK_TIMEOUT_EN,
		cryp->base + PE_TOKEN_CTRL_STAT);

		/* Clear all pending interrupts */
		writel(MTK_AIC_G_CLR, cryp->base + AIC_G_ACK);
		writel(MTK_PE_INPUT_DMA_ERR \| MTK_PE_OUTPUT_DMA_ERR \|
		MTK_PE_PKT_PORC_ERR \| MTK_PE_PKT_TIMEOUT \|
		MTK_PE_FATAL_ERR \| MTK_PE_INPUT_DMA_ERR_EN \|
		MTK_PE_OUTPUT_DMA_ERR_EN \| MTK_PE_PKT_PORC_ERR_EN \|
		MTK_PE_PKT_TIMEOUT_EN \| MTK_PE_FATAL_ERR_EN \|
		MTK_PE_INT_OUT_EN,
		cryp->base + PE_INTERRUPT_CTRL_STAT);

		return 0;
		}

		static int mtk_aic_cap_check(struct mtk_cryp *cryp, int hw)
		{
		u32 val;

		if (hw == MTK_RING_MAX)
		val = readl(cryp->base + AIC_G_VERSION);
		else
		val = readl(cryp->base + AIC_VERSION(hw));

		val &= MTK_AIC_VER_MSK;
		if (val != MTK_AIC_VER11 && val != MTK_AIC_VER12)
		return -ENXIO;

		if (hw == MTK_RING_MAX)
		val = readl(cryp->base + AIC_G_OPTIONS);
		else
		val = readl(cryp->base + AIC_OPTIONS(hw));

		val &= MTK_AIC_INT_MSK;
		if (!val \|\| val > 32)
		return -ENXIO;

		return 0;
		}

		static int mtk_aic_init(struct mtk_cryp *cryp, int hw)
		{
		int err;

		err = mtk_aic_cap_check(cryp, hw);
		if (err)
		return err;

		/* Disable all interrupts and set initial configuration */
		if (hw == MTK_RING_MAX) {
		writel(0, cryp->base + AIC_G_ENABLE_CTRL);
		writel(0, cryp->base + AIC_G_POL_CTRL);
		writel(0, cryp->base + AIC_G_TYPE_CTRL);
		writel(0, cryp->base + AIC_G_ENABLE_SET);
		} else {
		writel(0, cryp->base + AIC_ENABLE_CTRL(hw));
		writel(0, cryp->base + AIC_POL_CTRL(hw));
		writel(0, cryp->base + AIC_TYPE_CTRL(hw));
		writel(0, cryp->base + AIC_ENABLE_SET(hw));
		}

		return 0;
		}

		static int mtk_accelerator_init(struct mtk_cryp *cryp)
		{
		int i, err;

		/* Initialize advanced interrupt controller(AIC) */
		for (i = 0; i < MTK_IRQ_NUM; i++) {
		err = mtk_aic_init(cryp, i);
		if (err) {
		dev_err(cryp->dev, "Failed to initialize AIC.\n");
		return err;
		}
		}

		/* Initialize packet engine */
		err = mtk_packet_engine_setup(cryp);
		if (err) {
		dev_err(cryp->dev, "Failed to configure packet engine.\n");
		return err;
		}

		return 0;
		}

		static void mtk_desc_dma_free(struct mtk_cryp *cryp)
		{
		int i;

		for (i = 0; i < MTK_RING_MAX; i++) {
		dma_free_coherent(cryp->dev, MTK_DESC_RING_SZ,
		cryp->ring[i]->res_base,
		cryp->ring[i]->res_dma);
		dma_free_coherent(cryp->dev, MTK_DESC_RING_SZ,
		cryp->ring[i]->cmd_base,
		cryp->ring[i]->cmd_dma);
		kfree(cryp->ring[i]);
		}
		}

		static int mtk_desc_ring_alloc(struct mtk_cryp *cryp)
		{
		struct mtk_ring **ring = cryp->ring;
		int i;

		for (i = 0; i < MTK_RING_MAX; i++) {
		ring[i] = kzalloc(sizeof(**ring), GFP_KERNEL);
		if (!ring[i])
		goto err_cleanup;

		ring[i]->cmd_base = dma_alloc_coherent(cryp->dev,
		MTK_DESC_RING_SZ,
		&ring[i]->cmd_dma,
		GFP_KERNEL);
		if (!ring[i]->cmd_base)
		goto err_cleanup;

		ring[i]->res_base = dma_alloc_coherent(cryp->dev,
		MTK_DESC_RING_SZ,
		&ring[i]->res_dma,
		GFP_KERNEL);
		if (!ring[i]->res_base)
		goto err_cleanup;

		ring[i]->cmd_next = ring[i]->cmd_base;
		ring[i]->res_next = ring[i]->res_base;
		}
		return 0;

		err_cleanup:
		do {
		dma_free_coherent(cryp->dev, MTK_DESC_RING_SZ,
		ring[i]->res_base, ring[i]->res_dma);
		dma_free_coherent(cryp->dev, MTK_DESC_RING_SZ,
		ring[i]->cmd_base, ring[i]->cmd_dma);
		kfree(ring[i]);
		} while (i--);
		return -ENOMEM;
		}

		static int mtk_crypto_probe(struct platform_device *pdev)
		{
		struct mtk_cryp *cryp;
		int i, err;

		cryp = devm_kzalloc(&pdev->dev, sizeof(*cryp), GFP_KERNEL);
		if (!cryp)
		return -ENOMEM;

		cryp->base = devm_platform_ioremap_resource(pdev, 0);
		if (IS_ERR(cryp->base))
		return PTR_ERR(cryp->base);

		for (i = 0; i < MTK_IRQ_NUM; i++) {
		cryp->irq[i] = platform_get_irq(pdev, i);
		if (cryp->irq[i] < 0)
		return cryp->irq[i];
		}

		cryp->clk_cryp = devm_clk_get(&pdev->dev, "cryp");
		if (IS_ERR(cryp->clk_cryp))
		return -EPROBE_DEFER;

		cryp->dev = &pdev->dev;
		pm_runtime_enable(cryp->dev);
		pm_runtime_get_sync(cryp->dev);

		err = clk_prepare_enable(cryp->clk_cryp);
		if (err)
		goto err_clk_cryp;

		/* Allocate four command/result descriptor rings */
		err = mtk_desc_ring_alloc(cryp);
		if (err) {
		dev_err(cryp->dev, "Unable to allocate descriptor rings.\n");
		goto err_resource;
		}

		/* Initialize hardware modules */
		err = mtk_accelerator_init(cryp);
		if (err) {
		dev_err(cryp->dev, "Failed to initialize cryptographic engine.\n");
		goto err_engine;
		}

		err = mtk_cipher_alg_register(cryp);
		if (err) {
		dev_err(cryp->dev, "Unable to register cipher algorithm.\n");
		goto err_cipher;
		}

		err = mtk_hash_alg_register(cryp);
		if (err) {
		dev_err(cryp->dev, "Unable to register hash algorithm.\n");
		goto err_hash;
		}

		platform_set_drvdata(pdev, cryp);
		return 0;

		err_hash:
		mtk_cipher_alg_release(cryp);
		err_cipher:
		mtk_dfe_dse_reset(cryp);
		err_engine:
		mtk_desc_dma_free(cryp);
		err_resource:
		clk_disable_unprepare(cryp->clk_cryp);
		err_clk_cryp:
		pm_runtime_put_sync(cryp->dev);
		pm_runtime_disable(cryp->dev);

		return err;
		}

		static int mtk_crypto_remove(struct platform_device *pdev)
		{
		struct mtk_cryp *cryp = platform_get_drvdata(pdev);

		mtk_hash_alg_release(cryp);
		mtk_cipher_alg_release(cryp);
		mtk_desc_dma_free(cryp);

		clk_disable_unprepare(cryp->clk_cryp);

		pm_runtime_put_sync(cryp->dev);
		pm_runtime_disable(cryp->dev);
		platform_set_drvdata(pdev, NULL);

		return 0;
		}

		static const struct of_device_id of_crypto_id[] = {
		{ .compatible = "mediatek,eip97-crypto" },
		{},
		};
		MODULE_DEVICE_TABLE(of, of_crypto_id);

		static struct platform_driver mtk_crypto_driver = {
		.probe = mtk_crypto_probe,
		.remove = mtk_crypto_remove,
		.driver = {
		.name = "mtk-crypto",
		.of_match_table = of_crypto_id,
		},
		};
		module_platform_driver(mtk_crypto_driver);

		MODULE_LICENSE("GPL");
		MODULE_AUTHOR("Ryder Lee <ryder.lee@mediatek.com>");
		MODULE_DESCRIPTION("Cryptographic accelerator driver for EIP97");