02db7d73cf8b826ad1f64f9c7eb59136d5f60a6a
[karo-tx-linux.git] / arch / powerpc / platforms / powernv / rng.c
1 /*
2  * Copyright 2013, Michael Ellerman, IBM Corporation.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version
7  * 2 of the License, or (at your option) any later version.
8  */
9
10 #define pr_fmt(fmt)     "powernv-rng: " fmt
11
12 #include <linux/kernel.h>
13 #include <linux/of.h>
14 #include <linux/of_platform.h>
15 #include <linux/slab.h>
16 #include <asm/archrandom.h>
17 #include <asm/io.h>
18 #include <asm/machdep.h>
19
20
21 struct powernv_rng {
22         void __iomem *regs;
23         unsigned long mask;
24 };
25
26 static DEFINE_PER_CPU(struct powernv_rng *, powernv_rng);
27
28
29 static unsigned long rng_whiten(struct powernv_rng *rng, unsigned long val)
30 {
31         unsigned long parity;
32
33         /* Calculate the parity of the value */
34         asm ("popcntd %0,%1" : "=r" (parity) : "r" (val));
35
36         /* xor our value with the previous mask */
37         val ^= rng->mask;
38
39         /* update the mask based on the parity of this value */
40         rng->mask = (rng->mask << 1) | (parity & 1);
41
42         return val;
43 }
44
45 int powernv_get_random_long(unsigned long *v)
46 {
47         struct powernv_rng *rng;
48
49         rng = get_cpu_var(powernv_rng);
50
51         *v = rng_whiten(rng, in_be64(rng->regs));
52
53         put_cpu_var(rng);
54
55         return 1;
56 }
57 EXPORT_SYMBOL_GPL(powernv_get_random_long);
58
59 static __init void rng_init_per_cpu(struct powernv_rng *rng,
60                                     struct device_node *dn)
61 {
62         int chip_id, cpu;
63
64         chip_id = of_get_ibm_chip_id(dn);
65         if (chip_id == -1)
66                 pr_warn("No ibm,chip-id found for %s.\n", dn->full_name);
67
68         for_each_possible_cpu(cpu) {
69                 if (per_cpu(powernv_rng, cpu) == NULL ||
70                     cpu_to_chip_id(cpu) == chip_id) {
71                         per_cpu(powernv_rng, cpu) = rng;
72                 }
73         }
74 }
75
76 static __init int rng_create(struct device_node *dn)
77 {
78         struct powernv_rng *rng;
79         unsigned long val;
80
81         rng = kzalloc(sizeof(*rng), GFP_KERNEL);
82         if (!rng)
83                 return -ENOMEM;
84
85         rng->regs = of_iomap(dn, 0);
86         if (!rng->regs) {
87                 kfree(rng);
88                 return -ENXIO;
89         }
90
91         val = in_be64(rng->regs);
92         rng->mask = val;
93
94         rng_init_per_cpu(rng, dn);
95
96         pr_info_once("Registering arch random hook.\n");
97
98         ppc_md.get_random_long = powernv_get_random_long;
99
100         return 0;
101 }
102
103 static __init int rng_init(void)
104 {
105         struct device_node *dn;
106         int rc;
107
108         for_each_compatible_node(dn, NULL, "ibm,power-rng") {
109                 rc = rng_create(dn);
110                 if (rc) {
111                         pr_err("Failed creating rng for %s (%d).\n",
112                                 dn->full_name, rc);
113                         continue;
114                 }
115
116                 /* Create devices for hwrng driver */
117                 of_platform_device_create(dn, NULL, NULL);
118         }
119
120         return 0;
121 }
122 subsys_initcall(rng_init);