mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-13 14:14:37 +00:00
16bdbae394
Most hw_random devices return entropy which is assumed to be of full
quality, but driver authors don't bother setting the quality knob. Some
hw_random devices return less than full quality entropy, and then driver
authors set the quality knob. Therefore, the entropy crediting should be
opt-out rather than opt-in per-driver, to reflect the actual reality on
the ground.
For example, the two Raspberry Pi RNG drivers produce full entropy
randomness, and both EDK2 and U-Boot's drivers for these treat them as
such. The result is that EFI then uses these numbers and passes the to
Linux, and Linux credits them as boot, thereby initializing the RNG.
Yet, in Linux, the quality knob was never set to anything, and so on the
chance that Linux is booted without EFI, nothing is ever credited.
That's annoying.
The same pattern appears to repeat itself throughout various drivers. In
fact, very very few drivers have bothered setting quality=1024.
Looking at the git history of existing drivers and corresponding mailing
list discussion, this conclusion tracks. There's been a decent amount of
discussion about drivers that set quality < 1024 -- somebody read and
interepreted a datasheet, or made some back of the envelope calculation
somehow. But there's been very little, if any, discussion about most
drivers where the quality is just set to 1024 or unset (or set to 1000
when the authors misunderstood the API and assumed it was base-10 rather
than base-2); in both cases the intent was fairly clear of, "this is a
hardware random device; it's fine."
So let's invert this logic. A hw_random struct's quality knob now
controls the maximum quality a driver can produce, or 0 to specify 1024.
Then, the module-wide switch called "default_quality" is changed to
represent the maximum quality of any driver. By default it's 1024, and
the quality of any particular driver is then given by:
min(default_quality, rng->quality ?: 1024);
This way, the user can still turn this off for weird reasons (and we can
replace whatever driver-specific disabling hacks existed in the past),
yet we get proper crediting for relevant RNGs.
Cc: Dominik Brodowski <linux@dominikbrodowski.net>
Cc: Ard Biesheuvel <ardb@kernel.org>
Cc: Herbert Xu <herbert@gondor.apana.org.au>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
103 lines
2.5 KiB
C
103 lines
2.5 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Microchip PolarFire SoC (MPFS) hardware random driver
|
|
*
|
|
* Copyright (c) 2020-2022 Microchip Corporation. All rights reserved.
|
|
*
|
|
* Author: Conor Dooley <conor.dooley@microchip.com>
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/hw_random.h>
|
|
#include <linux/platform_device.h>
|
|
#include <soc/microchip/mpfs.h>
|
|
|
|
#define CMD_OPCODE 0x21
|
|
#define CMD_DATA_SIZE 0U
|
|
#define CMD_DATA NULL
|
|
#define MBOX_OFFSET 0U
|
|
#define RESP_OFFSET 0U
|
|
#define RNG_RESP_BYTES 32U
|
|
|
|
struct mpfs_rng {
|
|
struct mpfs_sys_controller *sys_controller;
|
|
struct hwrng rng;
|
|
};
|
|
|
|
static int mpfs_rng_read(struct hwrng *rng, void *buf, size_t max, bool wait)
|
|
{
|
|
struct mpfs_rng *rng_priv = container_of(rng, struct mpfs_rng, rng);
|
|
u32 response_msg[RNG_RESP_BYTES / sizeof(u32)];
|
|
unsigned int count = 0, copy_size_bytes;
|
|
int ret;
|
|
|
|
struct mpfs_mss_response response = {
|
|
.resp_status = 0U,
|
|
.resp_msg = (u32 *)response_msg,
|
|
.resp_size = RNG_RESP_BYTES
|
|
};
|
|
struct mpfs_mss_msg msg = {
|
|
.cmd_opcode = CMD_OPCODE,
|
|
.cmd_data_size = CMD_DATA_SIZE,
|
|
.response = &response,
|
|
.cmd_data = CMD_DATA,
|
|
.mbox_offset = MBOX_OFFSET,
|
|
.resp_offset = RESP_OFFSET
|
|
};
|
|
|
|
while (count < max) {
|
|
ret = mpfs_blocking_transaction(rng_priv->sys_controller, &msg);
|
|
if (ret)
|
|
return ret;
|
|
|
|
copy_size_bytes = max - count > RNG_RESP_BYTES ? RNG_RESP_BYTES : max - count;
|
|
memcpy(buf + count, response_msg, copy_size_bytes);
|
|
|
|
count += copy_size_bytes;
|
|
if (!wait)
|
|
break;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
static int mpfs_rng_probe(struct platform_device *pdev)
|
|
{
|
|
struct device *dev = &pdev->dev;
|
|
struct mpfs_rng *rng_priv;
|
|
int ret;
|
|
|
|
rng_priv = devm_kzalloc(dev, sizeof(*rng_priv), GFP_KERNEL);
|
|
if (!rng_priv)
|
|
return -ENOMEM;
|
|
|
|
rng_priv->sys_controller = mpfs_sys_controller_get(&pdev->dev);
|
|
if (IS_ERR(rng_priv->sys_controller))
|
|
return dev_err_probe(dev, PTR_ERR(rng_priv->sys_controller),
|
|
"Failed to register system controller hwrng sub device\n");
|
|
|
|
rng_priv->rng.read = mpfs_rng_read;
|
|
rng_priv->rng.name = pdev->name;
|
|
|
|
platform_set_drvdata(pdev, rng_priv);
|
|
|
|
ret = devm_hwrng_register(&pdev->dev, &rng_priv->rng);
|
|
if (ret)
|
|
return dev_err_probe(&pdev->dev, ret, "Failed to register MPFS hwrng\n");
|
|
|
|
dev_info(&pdev->dev, "Registered MPFS hwrng\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct platform_driver mpfs_rng_driver = {
|
|
.driver = {
|
|
.name = "mpfs-rng",
|
|
},
|
|
.probe = mpfs_rng_probe,
|
|
};
|
|
module_platform_driver(mpfs_rng_driver);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("Conor Dooley <conor.dooley@microchip.com>");
|
|
MODULE_DESCRIPTION("PolarFire SoC (MPFS) hardware random driver");
|