1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include "rk3288_crypto.h"
16#include <linux/module.h>
17#include <linux/platform_device.h>
18#include <linux/of.h>
19#include <linux/clk.h>
20#include <linux/crypto.h>
21#include <linux/reset.h>
22
23static int rk_crypto_enable_clk(struct rk_crypto_info *dev)
24{
25 int err;
26
27 err = clk_prepare_enable(dev->sclk);
28 if (err) {
29 dev_err(dev->dev, "[%s:%d], Couldn't enable clock sclk\n",
30 __func__, __LINE__);
31 goto err_return;
32 }
33 err = clk_prepare_enable(dev->aclk);
34 if (err) {
35 dev_err(dev->dev, "[%s:%d], Couldn't enable clock aclk\n",
36 __func__, __LINE__);
37 goto err_aclk;
38 }
39 err = clk_prepare_enable(dev->hclk);
40 if (err) {
41 dev_err(dev->dev, "[%s:%d], Couldn't enable clock hclk\n",
42 __func__, __LINE__);
43 goto err_hclk;
44 }
45 err = clk_prepare_enable(dev->dmaclk);
46 if (err) {
47 dev_err(dev->dev, "[%s:%d], Couldn't enable clock dmaclk\n",
48 __func__, __LINE__);
49 goto err_dmaclk;
50 }
51 return err;
52err_dmaclk:
53 clk_disable_unprepare(dev->hclk);
54err_hclk:
55 clk_disable_unprepare(dev->aclk);
56err_aclk:
57 clk_disable_unprepare(dev->sclk);
58err_return:
59 return err;
60}
61
62static void rk_crypto_disable_clk(struct rk_crypto_info *dev)
63{
64 clk_disable_unprepare(dev->dmaclk);
65 clk_disable_unprepare(dev->hclk);
66 clk_disable_unprepare(dev->aclk);
67 clk_disable_unprepare(dev->sclk);
68}
69
70static int check_alignment(struct scatterlist *sg_src,
71 struct scatterlist *sg_dst,
72 int align_mask)
73{
74 int in, out, align;
75
76 in = IS_ALIGNED((uint32_t)sg_src->offset, 4) &&
77 IS_ALIGNED((uint32_t)sg_src->length, align_mask);
78 if (!sg_dst)
79 return in;
80 out = IS_ALIGNED((uint32_t)sg_dst->offset, 4) &&
81 IS_ALIGNED((uint32_t)sg_dst->length, align_mask);
82 align = in && out;
83
84 return (align && (sg_src->length == sg_dst->length));
85}
86
87static int rk_load_data(struct rk_crypto_info *dev,
88 struct scatterlist *sg_src,
89 struct scatterlist *sg_dst)
90{
91 unsigned int count;
92
93 dev->aligned = dev->aligned ?
94 check_alignment(sg_src, sg_dst, dev->align_size) :
95 dev->aligned;
96 if (dev->aligned) {
97 count = min(dev->left_bytes, sg_src->length);
98 dev->left_bytes -= count;
99
100 if (!dma_map_sg(dev->dev, sg_src, 1, DMA_TO_DEVICE)) {
101 dev_err(dev->dev, "[%s:%d] dma_map_sg(src) error\n",
102 __func__, __LINE__);
103 return -EINVAL;
104 }
105 dev->addr_in = sg_dma_address(sg_src);
106
107 if (sg_dst) {
108 if (!dma_map_sg(dev->dev, sg_dst, 1, DMA_FROM_DEVICE)) {
109 dev_err(dev->dev,
110 "[%s:%d] dma_map_sg(dst) error\n",
111 __func__, __LINE__);
112 dma_unmap_sg(dev->dev, sg_src, 1,
113 DMA_TO_DEVICE);
114 return -EINVAL;
115 }
116 dev->addr_out = sg_dma_address(sg_dst);
117 }
118 } else {
119 count = (dev->left_bytes > PAGE_SIZE) ?
120 PAGE_SIZE : dev->left_bytes;
121
122 if (!sg_pcopy_to_buffer(dev->first, dev->nents,
123 dev->addr_vir, count,
124 dev->total - dev->left_bytes)) {
125 dev_err(dev->dev, "[%s:%d] pcopy err\n",
126 __func__, __LINE__);
127 return -EINVAL;
128 }
129 dev->left_bytes -= count;
130 sg_init_one(&dev->sg_tmp, dev->addr_vir, count);
131 if (!dma_map_sg(dev->dev, &dev->sg_tmp, 1, DMA_TO_DEVICE)) {
132 dev_err(dev->dev, "[%s:%d] dma_map_sg(sg_tmp) error\n",
133 __func__, __LINE__);
134 return -ENOMEM;
135 }
136 dev->addr_in = sg_dma_address(&dev->sg_tmp);
137
138 if (sg_dst) {
139 if (!dma_map_sg(dev->dev, &dev->sg_tmp, 1,
140 DMA_FROM_DEVICE)) {
141 dev_err(dev->dev,
142 "[%s:%d] dma_map_sg(sg_tmp) error\n",
143 __func__, __LINE__);
144 dma_unmap_sg(dev->dev, &dev->sg_tmp, 1,
145 DMA_TO_DEVICE);
146 return -ENOMEM;
147 }
148 dev->addr_out = sg_dma_address(&dev->sg_tmp);
149 }
150 }
151 dev->count = count;
152 return 0;
153}
154
155static void rk_unload_data(struct rk_crypto_info *dev)
156{
157 struct scatterlist *sg_in, *sg_out;
158
159 sg_in = dev->aligned ? dev->sg_src : &dev->sg_tmp;
160 dma_unmap_sg(dev->dev, sg_in, 1, DMA_TO_DEVICE);
161
162 if (dev->sg_dst) {
163 sg_out = dev->aligned ? dev->sg_dst : &dev->sg_tmp;
164 dma_unmap_sg(dev->dev, sg_out, 1, DMA_FROM_DEVICE);
165 }
166}
167
168static irqreturn_t rk_crypto_irq_handle(int irq, void *dev_id)
169{
170 struct rk_crypto_info *dev = platform_get_drvdata(dev_id);
171 u32 interrupt_status;
172 int err = 0;
173
174 spin_lock(&dev->lock);
175 interrupt_status = CRYPTO_READ(dev, RK_CRYPTO_INTSTS);
176 CRYPTO_WRITE(dev, RK_CRYPTO_INTSTS, interrupt_status);
177 if (interrupt_status & 0x0a) {
178 dev_warn(dev->dev, "DMA Error\n");
179 err = -EFAULT;
180 } else if (interrupt_status & 0x05) {
181 err = dev->update(dev);
182 }
183 if (err)
184 dev->complete(dev, err);
185 spin_unlock(&dev->lock);
186 return IRQ_HANDLED;
187}
188
189static void rk_crypto_tasklet_cb(unsigned long data)
190{
191 struct rk_crypto_info *dev = (struct rk_crypto_info *)data;
192 struct crypto_async_request *async_req, *backlog;
193 unsigned long flags;
194 int err = 0;
195
196 spin_lock_irqsave(&dev->lock, flags);
197 backlog = crypto_get_backlog(&dev->queue);
198 async_req = crypto_dequeue_request(&dev->queue);
199 spin_unlock_irqrestore(&dev->lock, flags);
200 if (!async_req) {
201 dev_err(dev->dev, "async_req is NULL !!\n");
202 return;
203 }
204 if (backlog) {
205 backlog->complete(backlog, -EINPROGRESS);
206 backlog = NULL;
207 }
208
209 if (crypto_tfm_alg_type(async_req->tfm) == CRYPTO_ALG_TYPE_ABLKCIPHER)
210 dev->ablk_req = ablkcipher_request_cast(async_req);
211 else
212 dev->ahash_req = ahash_request_cast(async_req);
213 err = dev->start(dev);
214 if (err)
215 dev->complete(dev, err);
216}
217
218static struct rk_crypto_tmp *rk_cipher_algs[] = {
219 &rk_ecb_aes_alg,
220 &rk_cbc_aes_alg,
221 &rk_ecb_des_alg,
222 &rk_cbc_des_alg,
223 &rk_ecb_des3_ede_alg,
224 &rk_cbc_des3_ede_alg,
225 &rk_ahash_sha1,
226 &rk_ahash_sha256,
227 &rk_ahash_md5,
228};
229
230static int rk_crypto_register(struct rk_crypto_info *crypto_info)
231{
232 unsigned int i, k;
233 int err = 0;
234
235 for (i = 0; i < ARRAY_SIZE(rk_cipher_algs); i++) {
236 rk_cipher_algs[i]->dev = crypto_info;
237 if (rk_cipher_algs[i]->type == ALG_TYPE_CIPHER)
238 err = crypto_register_alg(
239 &rk_cipher_algs[i]->alg.crypto);
240 else
241 err = crypto_register_ahash(
242 &rk_cipher_algs[i]->alg.hash);
243 if (err)
244 goto err_cipher_algs;
245 }
246 return 0;
247
248err_cipher_algs:
249 for (k = 0; k < i; k++) {
250 if (rk_cipher_algs[i]->type == ALG_TYPE_CIPHER)
251 crypto_unregister_alg(&rk_cipher_algs[k]->alg.crypto);
252 else
253 crypto_unregister_ahash(&rk_cipher_algs[i]->alg.hash);
254 }
255 return err;
256}
257
258static void rk_crypto_unregister(void)
259{
260 unsigned int i;
261
262 for (i = 0; i < ARRAY_SIZE(rk_cipher_algs); i++) {
263 if (rk_cipher_algs[i]->type == ALG_TYPE_CIPHER)
264 crypto_unregister_alg(&rk_cipher_algs[i]->alg.crypto);
265 else
266 crypto_unregister_ahash(&rk_cipher_algs[i]->alg.hash);
267 }
268}
269
270static void rk_crypto_action(void *data)
271{
272 struct rk_crypto_info *crypto_info = data;
273
274 reset_control_assert(crypto_info->rst);
275}
276
277static const struct of_device_id crypto_of_id_table[] = {
278 { .compatible = "rockchip,rk3288-crypto" },
279 {}
280};
281MODULE_DEVICE_TABLE(of, crypto_of_id_table);
282
283static int rk_crypto_probe(struct platform_device *pdev)
284{
285 struct resource *res;
286 struct device *dev = &pdev->dev;
287 struct rk_crypto_info *crypto_info;
288 int err = 0;
289
290 crypto_info = devm_kzalloc(&pdev->dev,
291 sizeof(*crypto_info), GFP_KERNEL);
292 if (!crypto_info) {
293 err = -ENOMEM;
294 goto err_crypto;
295 }
296
297 crypto_info->rst = devm_reset_control_get(dev, "crypto-rst");
298 if (IS_ERR(crypto_info->rst)) {
299 err = PTR_ERR(crypto_info->rst);
300 goto err_crypto;
301 }
302
303 reset_control_assert(crypto_info->rst);
304 usleep_range(10, 20);
305 reset_control_deassert(crypto_info->rst);
306
307 err = devm_add_action(dev, rk_crypto_action, crypto_info);
308 if (err) {
309 reset_control_assert(crypto_info->rst);
310 goto err_crypto;
311 }
312
313 spin_lock_init(&crypto_info->lock);
314
315 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
316 crypto_info->reg = devm_ioremap_resource(&pdev->dev, res);
317 if (IS_ERR(crypto_info->reg)) {
318 err = PTR_ERR(crypto_info->reg);
319 goto err_crypto;
320 }
321
322 crypto_info->aclk = devm_clk_get(&pdev->dev, "aclk");
323 if (IS_ERR(crypto_info->aclk)) {
324 err = PTR_ERR(crypto_info->aclk);
325 goto err_crypto;
326 }
327
328 crypto_info->hclk = devm_clk_get(&pdev->dev, "hclk");
329 if (IS_ERR(crypto_info->hclk)) {
330 err = PTR_ERR(crypto_info->hclk);
331 goto err_crypto;
332 }
333
334 crypto_info->sclk = devm_clk_get(&pdev->dev, "sclk");
335 if (IS_ERR(crypto_info->sclk)) {
336 err = PTR_ERR(crypto_info->sclk);
337 goto err_crypto;
338 }
339
340 crypto_info->dmaclk = devm_clk_get(&pdev->dev, "apb_pclk");
341 if (IS_ERR(crypto_info->dmaclk)) {
342 err = PTR_ERR(crypto_info->dmaclk);
343 goto err_crypto;
344 }
345
346 crypto_info->irq = platform_get_irq(pdev, 0);
347 if (crypto_info->irq < 0) {
348 dev_warn(crypto_info->dev,
349 "control Interrupt is not available.\n");
350 err = crypto_info->irq;
351 goto err_crypto;
352 }
353
354 err = devm_request_irq(&pdev->dev, crypto_info->irq,
355 rk_crypto_irq_handle, IRQF_SHARED,
356 "rk-crypto", pdev);
357
358 if (err) {
359 dev_err(crypto_info->dev, "irq request failed.\n");
360 goto err_crypto;
361 }
362
363 crypto_info->dev = &pdev->dev;
364 platform_set_drvdata(pdev, crypto_info);
365
366 tasklet_init(&crypto_info->crypto_tasklet,
367 rk_crypto_tasklet_cb, (unsigned long)crypto_info);
368 crypto_init_queue(&crypto_info->queue, 50);
369
370 crypto_info->enable_clk = rk_crypto_enable_clk;
371 crypto_info->disable_clk = rk_crypto_disable_clk;
372 crypto_info->load_data = rk_load_data;
373 crypto_info->unload_data = rk_unload_data;
374
375 err = rk_crypto_register(crypto_info);
376 if (err) {
377 dev_err(dev, "err in register alg");
378 goto err_register_alg;
379 }
380
381 dev_info(dev, "Crypto Accelerator successfully registered\n");
382 return 0;
383
384err_register_alg:
385 tasklet_kill(&crypto_info->crypto_tasklet);
386err_crypto:
387 return err;
388}
389
390static int rk_crypto_remove(struct platform_device *pdev)
391{
392 struct rk_crypto_info *crypto_tmp = platform_get_drvdata(pdev);
393
394 rk_crypto_unregister();
395 tasklet_kill(&crypto_tmp->crypto_tasklet);
396 return 0;
397}
398
399static struct platform_driver crypto_driver = {
400 .probe = rk_crypto_probe,
401 .remove = rk_crypto_remove,
402 .driver = {
403 .name = "rk3288-crypto",
404 .of_match_table = crypto_of_id_table,
405 },
406};
407
408module_platform_driver(crypto_driver);
409
410MODULE_AUTHOR("Zain Wang <zain.wang@rock-chips.com>");
411MODULE_DESCRIPTION("Support for Rockchip's cryptographic engine");
412MODULE_LICENSE("GPL");
413
