2019-04-13 13:33:04 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2015-07-27 14:17:09 +03:00
|
|
|
/*
|
|
|
|
* Allwinner sunXi SoCs Security ID support.
|
|
|
|
*
|
|
|
|
* Copyright (c) 2013 Oliver Schinagl <oliver@schinagl.nl>
|
|
|
|
* Copyright (C) 2014 Maxime Ripard <maxime.ripard@free-electrons.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/io.h>
|
2017-03-31 15:44:48 +03:00
|
|
|
#include <linux/iopoll.h>
|
2015-07-27 14:17:09 +03:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/nvmem-provider.h>
|
|
|
|
#include <linux/of.h>
|
2017-03-31 15:44:47 +03:00
|
|
|
#include <linux/of_device.h>
|
2015-07-27 14:17:09 +03:00
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/random.h>
|
|
|
|
|
2017-03-31 15:44:48 +03:00
|
|
|
/* Registers and special values for doing register-based SID readout on H3 */
|
|
|
|
#define SUN8I_SID_PRCTL 0x40
|
|
|
|
#define SUN8I_SID_RDKEY 0x60
|
|
|
|
|
|
|
|
#define SUN8I_SID_OFFSET_MASK 0x1FF
|
|
|
|
#define SUN8I_SID_OFFSET_SHIFT 16
|
|
|
|
#define SUN8I_SID_OP_LOCK (0xAC << 8)
|
|
|
|
#define SUN8I_SID_READ BIT(1)
|
|
|
|
|
2017-03-31 15:44:47 +03:00
|
|
|
struct sunxi_sid_cfg {
|
2017-03-31 15:44:48 +03:00
|
|
|
u32 value_offset;
|
2017-03-31 15:44:47 +03:00
|
|
|
u32 size;
|
2017-03-31 15:44:48 +03:00
|
|
|
bool need_register_readout;
|
2017-03-31 15:44:47 +03:00
|
|
|
};
|
|
|
|
|
2015-07-27 14:17:09 +03:00
|
|
|
struct sunxi_sid {
|
|
|
|
void __iomem *base;
|
2017-03-31 15:44:48 +03:00
|
|
|
u32 value_offset;
|
2015-07-27 14:17:09 +03:00
|
|
|
};
|
|
|
|
|
2016-04-24 22:28:10 +03:00
|
|
|
static int sunxi_sid_read(void *context, unsigned int offset,
|
|
|
|
void *val, size_t bytes)
|
2015-07-27 14:17:09 +03:00
|
|
|
{
|
|
|
|
struct sunxi_sid *sid = context;
|
2017-03-31 15:44:48 +03:00
|
|
|
|
2019-04-13 13:32:52 +03:00
|
|
|
memcpy_fromio(val, sid->base + sid->value_offset + offset, bytes);
|
2015-07-27 14:17:09 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-03-31 15:44:48 +03:00
|
|
|
static int sun8i_sid_register_readout(const struct sunxi_sid *sid,
|
2018-03-09 17:47:17 +03:00
|
|
|
const unsigned int offset,
|
|
|
|
u32 *out)
|
2017-03-31 15:44:48 +03:00
|
|
|
{
|
|
|
|
u32 reg_val;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Set word, lock access, and set read command */
|
2018-03-09 17:47:17 +03:00
|
|
|
reg_val = (offset & SUN8I_SID_OFFSET_MASK)
|
2017-03-31 15:44:48 +03:00
|
|
|
<< SUN8I_SID_OFFSET_SHIFT;
|
|
|
|
reg_val |= SUN8I_SID_OP_LOCK | SUN8I_SID_READ;
|
|
|
|
writel(reg_val, sid->base + SUN8I_SID_PRCTL);
|
|
|
|
|
|
|
|
ret = readl_poll_timeout(sid->base + SUN8I_SID_PRCTL, reg_val,
|
|
|
|
!(reg_val & SUN8I_SID_READ), 100, 250000);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2018-03-09 17:47:17 +03:00
|
|
|
if (out)
|
|
|
|
*out = readl(sid->base + SUN8I_SID_RDKEY);
|
|
|
|
|
2017-03-31 15:44:48 +03:00
|
|
|
writel(0, sid->base + SUN8I_SID_PRCTL);
|
2018-03-09 17:47:17 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* On Allwinner H3, the value on the 0x200 offset of the SID controller seems
|
|
|
|
* to be not reliable at all.
|
|
|
|
* Read by the registers instead.
|
|
|
|
*/
|
|
|
|
static int sun8i_sid_read_by_reg(void *context, unsigned int offset,
|
|
|
|
void *val, size_t bytes)
|
|
|
|
{
|
|
|
|
struct sunxi_sid *sid = context;
|
nvmem: sunxi_sid: Optimize register read-out method
SID cells are 32-bit aligned, and a multiple of 32 bits in length. The
only outlier is the thermal sensor calibration data, which is 16 bits
per sensor. However a whole 64 bits is allocated for this purpose, so
we could consider it conforming to the rule above.
Also, the register read-out method assumes native endian, unlike the
direct MMIO method, which assumes big endian. Thus no endian conversion
is involved.
Under these assumptions, the register read-out method can be slightly
optimized. Instead of reading one word then discarding 3 bytes, read
the whole word directly into the buffer. However, for reads under 4
bytes or trailing bytes, we still use a scratch buffer to extract the
requested bytes.
We could go one step further if .word_size was 4, but changing that
would affect the sysfs interface's behavior.
Signed-off-by: Chen-Yu Tsai <wens@csie.org>
Acked-by: Maxime Ripard <maxime.ripard@bootlin.com>
Signed-off-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-04-13 13:32:50 +03:00
|
|
|
u32 word;
|
2018-03-09 17:47:17 +03:00
|
|
|
int ret;
|
|
|
|
|
nvmem: sunxi_sid: Optimize register read-out method
SID cells are 32-bit aligned, and a multiple of 32 bits in length. The
only outlier is the thermal sensor calibration data, which is 16 bits
per sensor. However a whole 64 bits is allocated for this purpose, so
we could consider it conforming to the rule above.
Also, the register read-out method assumes native endian, unlike the
direct MMIO method, which assumes big endian. Thus no endian conversion
is involved.
Under these assumptions, the register read-out method can be slightly
optimized. Instead of reading one word then discarding 3 bytes, read
the whole word directly into the buffer. However, for reads under 4
bytes or trailing bytes, we still use a scratch buffer to extract the
requested bytes.
We could go one step further if .word_size was 4, but changing that
would affect the sysfs interface's behavior.
Signed-off-by: Chen-Yu Tsai <wens@csie.org>
Acked-by: Maxime Ripard <maxime.ripard@bootlin.com>
Signed-off-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-04-13 13:32:50 +03:00
|
|
|
/* .stride = 4 so offset is guaranteed to be aligned */
|
|
|
|
while (bytes >= 4) {
|
|
|
|
ret = sun8i_sid_register_readout(sid, offset, val);
|
2018-03-09 17:47:17 +03:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
nvmem: sunxi_sid: Optimize register read-out method
SID cells are 32-bit aligned, and a multiple of 32 bits in length. The
only outlier is the thermal sensor calibration data, which is 16 bits
per sensor. However a whole 64 bits is allocated for this purpose, so
we could consider it conforming to the rule above.
Also, the register read-out method assumes native endian, unlike the
direct MMIO method, which assumes big endian. Thus no endian conversion
is involved.
Under these assumptions, the register read-out method can be slightly
optimized. Instead of reading one word then discarding 3 bytes, read
the whole word directly into the buffer. However, for reads under 4
bytes or trailing bytes, we still use a scratch buffer to extract the
requested bytes.
We could go one step further if .word_size was 4, but changing that
would affect the sysfs interface's behavior.
Signed-off-by: Chen-Yu Tsai <wens@csie.org>
Acked-by: Maxime Ripard <maxime.ripard@bootlin.com>
Signed-off-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-04-13 13:32:50 +03:00
|
|
|
|
|
|
|
val += 4;
|
|
|
|
offset += 4;
|
|
|
|
bytes -= 4;
|
2018-03-09 17:47:17 +03:00
|
|
|
}
|
|
|
|
|
nvmem: sunxi_sid: Optimize register read-out method
SID cells are 32-bit aligned, and a multiple of 32 bits in length. The
only outlier is the thermal sensor calibration data, which is 16 bits
per sensor. However a whole 64 bits is allocated for this purpose, so
we could consider it conforming to the rule above.
Also, the register read-out method assumes native endian, unlike the
direct MMIO method, which assumes big endian. Thus no endian conversion
is involved.
Under these assumptions, the register read-out method can be slightly
optimized. Instead of reading one word then discarding 3 bytes, read
the whole word directly into the buffer. However, for reads under 4
bytes or trailing bytes, we still use a scratch buffer to extract the
requested bytes.
We could go one step further if .word_size was 4, but changing that
would affect the sysfs interface's behavior.
Signed-off-by: Chen-Yu Tsai <wens@csie.org>
Acked-by: Maxime Ripard <maxime.ripard@bootlin.com>
Signed-off-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-04-13 13:32:50 +03:00
|
|
|
if (!bytes)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Handle any trailing bytes */
|
|
|
|
ret = sun8i_sid_register_readout(sid, offset, &word);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
memcpy(val, &word, bytes);
|
|
|
|
|
2017-03-31 15:44:48 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-27 14:17:09 +03:00
|
|
|
static int sunxi_sid_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
struct resource *res;
|
2019-04-13 13:32:51 +03:00
|
|
|
struct nvmem_config *nvmem_cfg;
|
2015-07-27 14:17:09 +03:00
|
|
|
struct nvmem_device *nvmem;
|
|
|
|
struct sunxi_sid *sid;
|
2019-04-13 13:32:49 +03:00
|
|
|
int size;
|
2015-07-27 14:17:09 +03:00
|
|
|
char *randomness;
|
2017-03-31 15:44:47 +03:00
|
|
|
const struct sunxi_sid_cfg *cfg;
|
2015-07-27 14:17:09 +03:00
|
|
|
|
|
|
|
sid = devm_kzalloc(dev, sizeof(*sid), GFP_KERNEL);
|
|
|
|
if (!sid)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2017-03-31 15:44:47 +03:00
|
|
|
cfg = of_device_get_match_data(dev);
|
|
|
|
if (!cfg)
|
|
|
|
return -EINVAL;
|
2017-03-31 15:44:48 +03:00
|
|
|
sid->value_offset = cfg->value_offset;
|
2017-03-31 15:44:47 +03:00
|
|
|
|
2015-07-27 14:17:09 +03:00
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
sid->base = devm_ioremap_resource(dev, res);
|
|
|
|
if (IS_ERR(sid->base))
|
|
|
|
return PTR_ERR(sid->base);
|
|
|
|
|
2017-03-31 15:44:47 +03:00
|
|
|
size = cfg->size;
|
|
|
|
|
2019-04-13 13:32:51 +03:00
|
|
|
nvmem_cfg = devm_kzalloc(dev, sizeof(*nvmem_cfg), GFP_KERNEL);
|
|
|
|
if (!nvmem_cfg)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
nvmem_cfg->dev = dev;
|
|
|
|
nvmem_cfg->name = "sunxi-sid";
|
2021-06-11 11:33:45 +03:00
|
|
|
nvmem_cfg->type = NVMEM_TYPE_OTP;
|
2019-04-13 13:32:51 +03:00
|
|
|
nvmem_cfg->read_only = true;
|
|
|
|
nvmem_cfg->size = cfg->size;
|
|
|
|
nvmem_cfg->word_size = 1;
|
|
|
|
nvmem_cfg->stride = 4;
|
|
|
|
nvmem_cfg->priv = sid;
|
2018-03-09 17:47:17 +03:00
|
|
|
if (cfg->need_register_readout)
|
2019-04-13 13:32:51 +03:00
|
|
|
nvmem_cfg->reg_read = sun8i_sid_read_by_reg;
|
2018-03-09 17:47:17 +03:00
|
|
|
else
|
2019-04-13 13:32:51 +03:00
|
|
|
nvmem_cfg->reg_read = sunxi_sid_read;
|
|
|
|
|
|
|
|
nvmem = devm_nvmem_register(dev, nvmem_cfg);
|
2015-07-27 14:17:09 +03:00
|
|
|
if (IS_ERR(nvmem))
|
|
|
|
return PTR_ERR(nvmem);
|
|
|
|
|
treewide: kzalloc() -> kcalloc()
The kzalloc() function has a 2-factor argument form, kcalloc(). This
patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a * b, gfp)
as well as handling cases of:
kzalloc(a * b * c, gfp)
with:
kzalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kzalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kzalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kzalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kzalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kzalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kzalloc
+ kcalloc
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kzalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kzalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kzalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kzalloc(sizeof(THING) * C2, ...)
|
kzalloc(sizeof(TYPE) * C2, ...)
|
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(C1 * C2, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * E2
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-13 00:03:40 +03:00
|
|
|
randomness = kzalloc(size, GFP_KERNEL);
|
2018-09-21 16:40:10 +03:00
|
|
|
if (!randomness)
|
|
|
|
return -ENOMEM;
|
2015-09-30 15:36:31 +03:00
|
|
|
|
2019-04-13 13:32:51 +03:00
|
|
|
nvmem_cfg->reg_read(sid, 0, randomness, size);
|
2015-07-27 14:17:09 +03:00
|
|
|
add_device_randomness(randomness, size);
|
|
|
|
kfree(randomness);
|
|
|
|
|
|
|
|
platform_set_drvdata(pdev, nvmem);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-03-31 15:44:47 +03:00
|
|
|
static const struct sunxi_sid_cfg sun4i_a10_cfg = {
|
|
|
|
.size = 0x10,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct sunxi_sid_cfg sun7i_a20_cfg = {
|
|
|
|
.size = 0x200,
|
|
|
|
};
|
|
|
|
|
2017-03-31 15:44:48 +03:00
|
|
|
static const struct sunxi_sid_cfg sun8i_h3_cfg = {
|
|
|
|
.value_offset = 0x200,
|
|
|
|
.size = 0x100,
|
|
|
|
.need_register_readout = true,
|
|
|
|
};
|
|
|
|
|
2017-10-24 12:54:34 +03:00
|
|
|
static const struct sunxi_sid_cfg sun50i_a64_cfg = {
|
|
|
|
.value_offset = 0x200,
|
|
|
|
.size = 0x100,
|
2019-08-18 12:33:41 +03:00
|
|
|
.need_register_readout = true,
|
2017-10-24 12:54:34 +03:00
|
|
|
};
|
|
|
|
|
2019-04-13 13:33:05 +03:00
|
|
|
static const struct sunxi_sid_cfg sun50i_h6_cfg = {
|
|
|
|
.value_offset = 0x200,
|
|
|
|
.size = 0x200,
|
|
|
|
};
|
|
|
|
|
2015-07-27 14:17:09 +03:00
|
|
|
static const struct of_device_id sunxi_sid_of_match[] = {
|
2017-03-31 15:44:47 +03:00
|
|
|
{ .compatible = "allwinner,sun4i-a10-sid", .data = &sun4i_a10_cfg },
|
|
|
|
{ .compatible = "allwinner,sun7i-a20-sid", .data = &sun7i_a20_cfg },
|
2019-04-13 13:32:53 +03:00
|
|
|
{ .compatible = "allwinner,sun8i-a83t-sid", .data = &sun50i_a64_cfg },
|
2017-03-31 15:44:48 +03:00
|
|
|
{ .compatible = "allwinner,sun8i-h3-sid", .data = &sun8i_h3_cfg },
|
2017-10-24 12:54:34 +03:00
|
|
|
{ .compatible = "allwinner,sun50i-a64-sid", .data = &sun50i_a64_cfg },
|
2019-04-13 13:32:53 +03:00
|
|
|
{ .compatible = "allwinner,sun50i-h5-sid", .data = &sun50i_a64_cfg },
|
2019-04-13 13:33:05 +03:00
|
|
|
{ .compatible = "allwinner,sun50i-h6-sid", .data = &sun50i_h6_cfg },
|
2015-07-27 14:17:09 +03:00
|
|
|
{/* sentinel */},
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, sunxi_sid_of_match);
|
|
|
|
|
|
|
|
static struct platform_driver sunxi_sid_driver = {
|
|
|
|
.probe = sunxi_sid_probe,
|
|
|
|
.driver = {
|
|
|
|
.name = "eeprom-sunxi-sid",
|
|
|
|
.of_match_table = sunxi_sid_of_match,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
module_platform_driver(sunxi_sid_driver);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Oliver Schinagl <oliver@schinagl.nl>");
|
|
|
|
MODULE_DESCRIPTION("Allwinner sunxi security id driver");
|
|
|
|
MODULE_LICENSE("GPL");
|