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 >
*
* This program is free software ; you can redistribute it and / or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation ; either version 2 of the License , or
* ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*/
# 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)
2015-07-27 14:17:09 +03:00
static struct nvmem_config econfig = {
. name = " sunxi-sid " ,
. read_only = true ,
2016-04-24 22:28:10 +03:00
. stride = 4 ,
. word_size = 1 ,
2015-07-27 14:17:09 +03:00
} ;
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
} ;
/* We read the entire key, due to a 32 bit read alignment requirement. Since we
* want to return the requested byte , this results in somewhat slower code and
* uses 4 times more reads as needed but keeps code simpler . Since the SID is
* only very rarely probed , this is not really an issue .
*/
static u8 sunxi_sid_read_byte ( const struct sunxi_sid * sid ,
const unsigned int offset )
{
u32 sid_key ;
sid_key = ioread32be ( sid - > base + round_down ( offset , 4 ) ) ;
sid_key > > = ( offset % 4 ) * 8 ;
return sid_key ; /* Only return the last byte */
}
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 ;
u8 * buf = val ;
2017-03-31 15:44:48 +03:00
/* Offset the read operation to the real position of SID */
offset + = sid - > value_offset ;
2016-04-24 22:28:10 +03:00
while ( bytes - - )
* buf + + = sunxi_sid_read_byte ( sid , offset + + ) ;
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_byte_by_reg ( const struct sunxi_sid * sid ,
const unsigned int offset ,
u8 * out )
{
u32 word ;
int ret ;
ret = sun8i_sid_register_readout ( sid , offset & ~ 0x03 , & word ) ;
if ( ret )
return ret ;
* out = ( word > > ( ( offset & 0x3 ) * 8 ) ) & 0xff ;
return 0 ;
}
static int sun8i_sid_read_by_reg ( void * context , unsigned int offset ,
void * val , size_t bytes )
{
struct sunxi_sid * sid = context ;
u8 * buf = val ;
int ret ;
while ( bytes - - ) {
ret = sun8i_sid_read_byte_by_reg ( sid , offset + + , buf + + ) ;
if ( ret )
return ret ;
}
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 ;
struct nvmem_device * nvmem ;
struct sunxi_sid * sid ;
2015-09-30 15:36:31 +03:00
int ret , i , 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 ;
econfig . size = size ;
2015-07-27 14:17:09 +03:00
econfig . dev = dev ;
2018-03-09 17:47:17 +03:00
if ( cfg - > need_register_readout )
econfig . reg_read = sun8i_sid_read_by_reg ;
else
econfig . reg_read = sunxi_sid_read ;
2016-04-24 22:28:10 +03:00
econfig . priv = sid ;
2015-07-27 14:17:09 +03:00
nvmem = nvmem_register ( & econfig ) ;
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 ) ;
2015-09-30 15:36:31 +03:00
if ( ! randomness ) {
2018-09-21 16:40:09 +03:00
ret = - ENOMEM ;
2015-09-30 15:36:31 +03:00
goto err_unreg_nvmem ;
}
2015-07-27 14:17:09 +03:00
for ( i = 0 ; i < size ; i + + )
2018-03-09 17:47:17 +03:00
econfig . reg_read ( sid , i , & randomness [ i ] , 1 ) ;
2015-07-27 14:17:09 +03:00
add_device_randomness ( randomness , size ) ;
kfree ( randomness ) ;
platform_set_drvdata ( pdev , nvmem ) ;
return 0 ;
2015-09-30 15:36:31 +03:00
err_unreg_nvmem :
nvmem_unregister ( nvmem ) ;
return ret ;
2015-07-27 14:17:09 +03:00
}
static int sunxi_sid_remove ( struct platform_device * pdev )
{
struct nvmem_device * nvmem = platform_get_drvdata ( pdev ) ;
return nvmem_unregister ( nvmem ) ;
}
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 ,
} ;
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 } ,
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 } ,
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 ,
. remove = sunxi_sid_remove ,
. 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 " ) ;