rng.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * Copyright 2013, Michael Ellerman, IBM Corporation.
  4 */
  5
  6#define pr_fmt(fmt)	"powernv-rng: " fmt
  7
  8#include <linux/kernel.h>
  9#include <linux/of.h>
 10#include <linux/of_address.h>
 11#include <linux/of_platform.h>
 12#include <linux/slab.h>
 13#include <linux/smp.h>
 14#include <asm/archrandom.h>
 15#include <asm/cputable.h>
 16#include <asm/io.h>
 17#include <asm/prom.h>
 18#include <asm/machdep.h>
 19#include <asm/smp.h>
 20#include "powernv.h"
 21
 22#define DARN_ERR 0xFFFFFFFFFFFFFFFFul
 23
 24struct pnv_rng {
 25	void __iomem *regs;
 26	void __iomem *regs_real;
 27	unsigned long mask;
 28};
 29
 30static DEFINE_PER_CPU(struct pnv_rng *, pnv_rng);
 31
 32static unsigned long rng_whiten(struct pnv_rng *rng, unsigned long val)
 33{
 34	unsigned long parity;
 35
 36	/* Calculate the parity of the value */
 37	asm (".machine push;   \
 38	      .machine power7; \
 39	      popcntd %0,%1;   \
 40	      .machine pop;"
 41	     : "=r" (parity) : "r" (val));
 42
 43	/* xor our value with the previous mask */
 44	val ^= rng->mask;
 45
 46	/* update the mask based on the parity of this value */
 47	rng->mask = (rng->mask << 1) | (parity & 1);
 48
 49	return val;
 50}
 51
 52static int pnv_get_random_darn(unsigned long *v)
 53{
 54	unsigned long val;
 55
 56	/* Using DARN with L=1 - 64-bit conditioned random number */
 57	asm volatile(PPC_DARN(%0, 1) : "=r"(val));
 58
 59	if (val == DARN_ERR)
 60		return 0;
 61
 62	*v = val;
 63
 64	return 1;
 65}
 66
 67static int __init initialise_darn(void)
 68{
 69	unsigned long val;
 70	int i;
 71
 72	if (!cpu_has_feature(CPU_FTR_ARCH_300))
 73		return -ENODEV;
 74
 75	for (i = 0; i < 10; i++) {
 76		if (pnv_get_random_darn(&val)) {
 77			ppc_md.get_random_seed = pnv_get_random_darn;
 78			return 0;
 79		}
 80	}
 81	return -EIO;
 82}
 83
 84int pnv_get_random_long(unsigned long *v)
 85{
 86	struct pnv_rng *rng;
 87
 88	if (mfmsr() & MSR_DR) {
 89		rng = get_cpu_var(pnv_rng);
 90		*v = rng_whiten(rng, in_be64(rng->regs));
 91		put_cpu_var(rng);
 92	} else {
 93		rng = raw_cpu_read(pnv_rng);
 94		*v = rng_whiten(rng, __raw_rm_readq(rng->regs_real));
 95	}
 96	return 1;
 97}
 98EXPORT_SYMBOL_GPL(pnv_get_random_long);
 99
100static __init void rng_init_per_cpu(struct pnv_rng *rng,
101				    struct device_node *dn)
102{
103	int chip_id, cpu;
104
105	chip_id = of_get_ibm_chip_id(dn);
106	if (chip_id == -1)
107		pr_warn("No ibm,chip-id found for %pOF.\n", dn);
108
109	for_each_possible_cpu(cpu) {
110		if (per_cpu(pnv_rng, cpu) == NULL ||
111		    cpu_to_chip_id(cpu) == chip_id) {
112			per_cpu(pnv_rng, cpu) = rng;
113		}
114	}
115}
116
117static __init int rng_create(struct device_node *dn)
118{
119	struct pnv_rng *rng;
120	struct resource res;
121	unsigned long val;
122
123	rng = kzalloc(sizeof(*rng), GFP_KERNEL);
124	if (!rng)
125		return -ENOMEM;
126
127	if (of_address_to_resource(dn, 0, &res)) {
128		kfree(rng);
129		return -ENXIO;
130	}
131
132	rng->regs_real = (void __iomem *)res.start;
133
134	rng->regs = of_iomap(dn, 0);
135	if (!rng->regs) {
136		kfree(rng);
137		return -ENXIO;
138	}
139
140	val = in_be64(rng->regs);
141	rng->mask = val;
142
143	rng_init_per_cpu(rng, dn);
144
145	ppc_md.get_random_seed = pnv_get_random_long;
146
147	return 0;
148}
149
150static int __init pnv_get_random_long_early(unsigned long *v)
151{
152	struct device_node *dn;
153
154	if (!slab_is_available())
155		return 0;
156
157	if (cmpxchg(&ppc_md.get_random_seed, pnv_get_random_long_early,
158		    NULL) != pnv_get_random_long_early)
159		return 0;
160
161	for_each_compatible_node(dn, NULL, "ibm,power-rng")
162		rng_create(dn);
163
164	if (!ppc_md.get_random_seed)
165		return 0;
166	return ppc_md.get_random_seed(v);
167}
168
169void __init pnv_rng_init(void)
170{
171	struct device_node *dn;
172
173	/* Prefer darn over the rest. */
174	if (!initialise_darn())
175		return;
176
177	dn = of_find_compatible_node(NULL, NULL, "ibm,power-rng");
178	if (dn)
179		ppc_md.get_random_seed = pnv_get_random_long_early;
180
181	of_node_put(dn);
182}
183
184static int __init pnv_rng_late_init(void)
185{
186	struct device_node *dn;
187	unsigned long v;
188
189	/* In case it wasn't called during init for some other reason. */
190	if (ppc_md.get_random_seed == pnv_get_random_long_early)
191		pnv_get_random_long_early(&v);
192
193	if (ppc_md.get_random_seed == pnv_get_random_long) {
194		for_each_compatible_node(dn, NULL, "ibm,power-rng")
195			of_platform_device_create(dn, NULL, NULL);
196	}
197
198	return 0;
199}
200machine_subsys_initcall(powernv, pnv_rng_late_init);