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 ;
2023-01-27 13:40:07 +03:00
u32 word ;
2017-03-31 15:44:48 +03:00
2023-01-27 13:40:07 +03:00
/* .stride = 4 so offset is guaranteed to be aligned */
__ioread32_copy ( val , sid - > base + sid - > value_offset + offset , bytes / 4 ) ;
val + = round_down ( bytes , 4 ) ;
offset + = round_down ( bytes , 4 ) ;
bytes = bytes % 4 ;
if ( ! bytes )
return 0 ;
/* Handle any trailing bytes */
word = readl_relaxed ( sid - > base + sid - > value_offset + offset ) ;
memcpy ( val , & word , 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 ,
} ;
2022-02-20 18:15:20 +03:00
static const struct sunxi_sid_cfg sun20i_d1_cfg = {
. value_offset = 0x200 ,
. size = 0x100 ,
} ;
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 } ,
2022-02-20 18:15:20 +03:00
{ . compatible = " allwinner,sun20i-d1-sid " , . data = & sun20i_d1_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 " ) ;