1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2020 Rockchip Electronics Co., Ltd.
4 */
5 #include <linux/iopoll.h>
6 #include <linux/kernel.h>
7 #include <linux/kthread.h>
8 #include <linux/mm.h>
9 #include <linux/module.h>
10 #include <linux/of.h>
11 #include <linux/of_address.h>
12 #include <linux/of_device.h>
13 #include <linux/platform_device.h>
14 #include <linux/soc/rockchip/rockchip_decompress.h>
15 #include <linux/soc/rockchip/rockchip_thunderboot_crypto.h>
16
17 #define SFC_ICLR 0x08
18 #define SFC_SR 0x24
19 #define SFC_RAWISR 0x28
20
21 /* SFC_SR Register */
22 #define SFC_BUSY BIT(0)
23
24 /* SFC_RAWISR Register */
25 #define DMA_INT BIT(7)
26
rk_tb_sfc_thread(void * p)27 static int rk_tb_sfc_thread(void *p)
28 {
29 int ret = 0;
30 struct platform_device *pdev = p;
31 void __iomem *regs;
32 struct resource *res;
33 struct device_node *rds, *rdd;
34 struct device *dev = &pdev->dev;
35 u32 status;
36
37 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
38 regs = ioremap(res->start, resource_size(res));
39 if (!regs) {
40 dev_err(dev, "ioremap failed for resource %pR\n", res);
41 return -ENOMEM;
42 }
43
44 rds = of_parse_phandle(dev->of_node, "memory-region-src", 0);
45 rdd = of_parse_phandle(dev->of_node, "memory-region-dst", 0);
46
47 #ifdef SFC_DEBUG
48 print_hex_dump(KERN_WARNING, "tb_sfc", DUMP_PREFIX_OFFSET, 4, 4, regs, 0x60, 0);
49 #endif
50
51 ret = readl_poll_timeout(regs + SFC_SR, status,
52 !(status & SFC_BUSY), 100,
53 1000 * USEC_PER_MSEC);
54 if (ret) {
55 dev_err(dev, "Wait for SFC idle timeout!\n");
56 goto out;
57 } else {
58 if (likely(readl(regs + SFC_RAWISR) & DMA_INT))
59 dev_err(dev, "DMA finished!\n");
60 else
61 dev_err(dev, "Last transfer non DMA!\n");
62 }
63
64 /* Parse ramdisk addr and help start decompressing */
65 if (rds && rdd) {
66 struct resource src, dst;
67 u32 rdk_size = 0;
68 const u32 *digest_org;
69
70 if (of_address_to_resource(rds, 0, &src) >= 0 &&
71 of_address_to_resource(rdd, 0, &dst) >= 0) {
72 if (IS_ENABLED(CONFIG_ROCKCHIP_THUNDER_BOOT_CRYPTO)) {
73 of_property_read_u32(rds, "size", &rdk_size);
74 digest_org = of_get_property(rds->child, "value", NULL);
75 if (digest_org && rdk_size)
76 rk_tb_sha256((dma_addr_t)src.start, rdk_size,
77 (void *)digest_org);
78 }
79 /*
80 * Decompress HW driver will free reserved area of
81 * memory-region-src.
82 */
83 ret = rk_decom_start(GZIP_MOD, src.start,
84 dst.start,
85 resource_size(&dst));
86 if (ret < 0)
87 dev_err(dev, "failed to start decom\n");
88 }
89 }
90
91 out:
92 of_node_put(rds);
93 of_node_put(rdd);
94 iounmap(regs);
95
96 return 0;
97 }
98
rk_tb_sfc_probe(struct platform_device * pdev)99 static int __init rk_tb_sfc_probe(struct platform_device *pdev)
100 {
101 int ret = 0;
102 struct task_struct *tsk;
103
104 tsk = kthread_run(rk_tb_sfc_thread, pdev, "tb_sfc");
105 if (IS_ERR(tsk)) {
106 ret = PTR_ERR(tsk);
107 dev_err(&pdev->dev, "start thread failed (%d)\n", ret);
108 }
109
110 return ret;
111 }
112
113 #ifdef CONFIG_OF
114 static const struct of_device_id rk_tb_sfc_dt_match[] = {
115 { .compatible = "rockchip,thunder-boot-sfc" },
116 {},
117 };
118 #endif
119
120 static struct platform_driver rk_tb_sfc_driver = {
121 .driver = {
122 .name = "rockchip_thunder_boot_sfc",
123 .of_match_table = rk_tb_sfc_dt_match,
124 },
125 };
126
rk_tb_sfc_init(void)127 static int __init rk_tb_sfc_init(void)
128 {
129 struct device_node *node;
130
131 node = of_find_matching_node(NULL, rk_tb_sfc_dt_match);
132 if (node) {
133 of_platform_device_create(node, NULL, NULL);
134 of_node_put(node);
135 return platform_driver_probe(&rk_tb_sfc_driver, rk_tb_sfc_probe);
136 }
137
138 return 0;
139 }
140
141 pure_initcall(rk_tb_sfc_init);
142