1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Random Number Generator driver for the Keystone SOC 4 * 5 * Copyright (C) 2016 Texas Instruments Incorporated - http://www.ti.com 6 * 7 * Authors: Sandeep Nair 8 * Vitaly Andrianov 9 */ 10 11 #include <linux/hw_random.h> 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/io.h> 15 #include <linux/platform_device.h> 16 #include <linux/clk.h> 17 #include <linux/pm_runtime.h> 18 #include <linux/err.h> 19 #include <linux/regmap.h> 20 #include <linux/mfd/syscon.h> 21 #include <linux/of.h> 22 #include <linux/of_address.h> 23 #include <linux/delay.h> 24 #include <linux/timekeeping.h> 25 26 #define SA_CMD_STATUS_OFS 0x8 27 28 /* TRNG enable control in SA System module*/ 29 #define SA_CMD_STATUS_REG_TRNG_ENABLE BIT(3) 30 31 /* TRNG start control in TRNG module */ 32 #define TRNG_CNTL_REG_TRNG_ENABLE BIT(10) 33 34 /* Data ready indicator in STATUS register */ 35 #define TRNG_STATUS_REG_READY BIT(0) 36 37 /* Data ready clear control in INTACK register */ 38 #define TRNG_INTACK_REG_READY BIT(0) 39 40 /* 41 * Number of samples taken to gather entropy during startup. 42 * If value is 0, the number of samples is 2^24 else 43 * equals value times 2^8. 44 */ 45 #define TRNG_DEF_STARTUP_CYCLES 0 46 #define TRNG_CNTL_REG_STARTUP_CYCLES_SHIFT 16 47 48 /* 49 * Minimum number of samples taken to regenerate entropy 50 * If value is 0, the number of samples is 2^24 else 51 * equals value times 2^6. 52 */ 53 #define TRNG_DEF_MIN_REFILL_CYCLES 1 54 #define TRNG_CFG_REG_MIN_REFILL_CYCLES_SHIFT 0 55 56 /* 57 * Maximum number of samples taken to regenerate entropy 58 * If value is 0, the number of samples is 2^24 else 59 * equals value times 2^8. 60 */ 61 #define TRNG_DEF_MAX_REFILL_CYCLES 0 62 #define TRNG_CFG_REG_MAX_REFILL_CYCLES_SHIFT 16 63 64 /* Number of CLK input cycles between samples */ 65 #define TRNG_DEF_CLK_DIV_CYCLES 0 66 #define TRNG_CFG_REG_SAMPLE_DIV_SHIFT 8 67 68 /* Maximum retries to get rng data */ 69 #define SA_MAX_RNG_DATA_RETRIES 5 70 /* Delay between retries (in usecs) */ 71 #define SA_RNG_DATA_RETRY_DELAY 5 72 73 struct trng_regs { 74 u32 output_l; 75 u32 output_h; 76 u32 status; 77 u32 intmask; 78 u32 intack; 79 u32 control; 80 u32 config; 81 }; 82 83 struct ks_sa_rng { 84 struct device *dev; 85 struct hwrng rng; 86 struct clk *clk; 87 struct regmap *regmap_cfg; 88 struct trng_regs __iomem *reg_rng; 89 u64 ready_ts; 90 unsigned int refill_delay_ns; 91 }; 92 93 static unsigned int cycles_to_ns(unsigned long clk_rate, unsigned int cycles) 94 { 95 return DIV_ROUND_UP_ULL((TRNG_DEF_CLK_DIV_CYCLES + 1) * 1000000000ull * 96 cycles, clk_rate); 97 } 98 99 static unsigned int startup_delay_ns(unsigned long clk_rate) 100 { 101 if (!TRNG_DEF_STARTUP_CYCLES) 102 return cycles_to_ns(clk_rate, BIT(24)); 103 return cycles_to_ns(clk_rate, 256 * TRNG_DEF_STARTUP_CYCLES); 104 } 105 106 static unsigned int refill_delay_ns(unsigned long clk_rate) 107 { 108 if (!TRNG_DEF_MAX_REFILL_CYCLES) 109 return cycles_to_ns(clk_rate, BIT(24)); 110 return cycles_to_ns(clk_rate, 256 * TRNG_DEF_MAX_REFILL_CYCLES); 111 } 112 113 static int ks_sa_rng_init(struct hwrng *rng) 114 { 115 u32 value; 116 struct device *dev = (struct device *)rng->priv; 117 struct ks_sa_rng *ks_sa_rng = dev_get_drvdata(dev); 118 unsigned long clk_rate = clk_get_rate(ks_sa_rng->clk); 119 120 /* Enable RNG module */ 121 regmap_write_bits(ks_sa_rng->regmap_cfg, SA_CMD_STATUS_OFS, 122 SA_CMD_STATUS_REG_TRNG_ENABLE, 123 SA_CMD_STATUS_REG_TRNG_ENABLE); 124 125 /* Configure RNG module */ 126 writel(0, &ks_sa_rng->reg_rng->control); 127 value = TRNG_DEF_STARTUP_CYCLES << TRNG_CNTL_REG_STARTUP_CYCLES_SHIFT; 128 writel(value, &ks_sa_rng->reg_rng->control); 129 130 value = (TRNG_DEF_MIN_REFILL_CYCLES << 131 TRNG_CFG_REG_MIN_REFILL_CYCLES_SHIFT) | 132 (TRNG_DEF_MAX_REFILL_CYCLES << 133 TRNG_CFG_REG_MAX_REFILL_CYCLES_SHIFT) | 134 (TRNG_DEF_CLK_DIV_CYCLES << 135 TRNG_CFG_REG_SAMPLE_DIV_SHIFT); 136 137 writel(value, &ks_sa_rng->reg_rng->config); 138 139 /* Disable all interrupts from TRNG */ 140 writel(0, &ks_sa_rng->reg_rng->intmask); 141 142 /* Enable RNG */ 143 value = readl(&ks_sa_rng->reg_rng->control); 144 value |= TRNG_CNTL_REG_TRNG_ENABLE; 145 writel(value, &ks_sa_rng->reg_rng->control); 146 147 ks_sa_rng->refill_delay_ns = refill_delay_ns(clk_rate); 148 ks_sa_rng->ready_ts = ktime_get_ns() + 149 startup_delay_ns(clk_rate); 150 151 return 0; 152 } 153 154 static void ks_sa_rng_cleanup(struct hwrng *rng) 155 { 156 struct device *dev = (struct device *)rng->priv; 157 struct ks_sa_rng *ks_sa_rng = dev_get_drvdata(dev); 158 159 /* Disable RNG */ 160 writel(0, &ks_sa_rng->reg_rng->control); 161 regmap_write_bits(ks_sa_rng->regmap_cfg, SA_CMD_STATUS_OFS, 162 SA_CMD_STATUS_REG_TRNG_ENABLE, 0); 163 } 164 165 static int ks_sa_rng_data_read(struct hwrng *rng, u32 *data) 166 { 167 struct device *dev = (struct device *)rng->priv; 168 struct ks_sa_rng *ks_sa_rng = dev_get_drvdata(dev); 169 170 /* Read random data */ 171 data[0] = readl(&ks_sa_rng->reg_rng->output_l); 172 data[1] = readl(&ks_sa_rng->reg_rng->output_h); 173 174 writel(TRNG_INTACK_REG_READY, &ks_sa_rng->reg_rng->intack); 175 ks_sa_rng->ready_ts = ktime_get_ns() + ks_sa_rng->refill_delay_ns; 176 177 return sizeof(u32) * 2; 178 } 179 180 static int ks_sa_rng_data_present(struct hwrng *rng, int wait) 181 { 182 struct device *dev = (struct device *)rng->priv; 183 struct ks_sa_rng *ks_sa_rng = dev_get_drvdata(dev); 184 u64 now = ktime_get_ns(); 185 186 u32 ready; 187 int j; 188 189 if (wait && now < ks_sa_rng->ready_ts) { 190 /* Max delay expected here is 81920000 ns */ 191 unsigned long min_delay = 192 DIV_ROUND_UP((u32)(ks_sa_rng->ready_ts - now), 1000); 193 194 usleep_range(min_delay, min_delay + SA_RNG_DATA_RETRY_DELAY); 195 } 196 197 for (j = 0; j < SA_MAX_RNG_DATA_RETRIES; j++) { 198 ready = readl(&ks_sa_rng->reg_rng->status); 199 ready &= TRNG_STATUS_REG_READY; 200 201 if (ready || !wait) 202 break; 203 204 udelay(SA_RNG_DATA_RETRY_DELAY); 205 } 206 207 return ready; 208 } 209 210 static int ks_sa_rng_probe(struct platform_device *pdev) 211 { 212 struct ks_sa_rng *ks_sa_rng; 213 struct device *dev = &pdev->dev; 214 int ret; 215 216 ks_sa_rng = devm_kzalloc(dev, sizeof(*ks_sa_rng), GFP_KERNEL); 217 if (!ks_sa_rng) 218 return -ENOMEM; 219 220 ks_sa_rng->dev = dev; 221 ks_sa_rng->rng = (struct hwrng) { 222 .name = "ks_sa_hwrng", 223 .init = ks_sa_rng_init, 224 .data_read = ks_sa_rng_data_read, 225 .data_present = ks_sa_rng_data_present, 226 .cleanup = ks_sa_rng_cleanup, 227 }; 228 ks_sa_rng->rng.priv = (unsigned long)dev; 229 230 ks_sa_rng->reg_rng = devm_platform_ioremap_resource(pdev, 0); 231 if (IS_ERR(ks_sa_rng->reg_rng)) 232 return PTR_ERR(ks_sa_rng->reg_rng); 233 234 ks_sa_rng->regmap_cfg = 235 syscon_regmap_lookup_by_phandle(dev->of_node, 236 "ti,syscon-sa-cfg"); 237 238 if (IS_ERR(ks_sa_rng->regmap_cfg)) { 239 dev_err(dev, "syscon_node_to_regmap failed\n"); 240 return -EINVAL; 241 } 242 243 pm_runtime_enable(dev); 244 ret = pm_runtime_get_sync(dev); 245 if (ret < 0) { 246 dev_err(dev, "Failed to enable SA power-domain\n"); 247 pm_runtime_put_noidle(dev); 248 pm_runtime_disable(dev); 249 return ret; 250 } 251 252 platform_set_drvdata(pdev, ks_sa_rng); 253 254 return devm_hwrng_register(&pdev->dev, &ks_sa_rng->rng); 255 } 256 257 static int ks_sa_rng_remove(struct platform_device *pdev) 258 { 259 pm_runtime_put_sync(&pdev->dev); 260 pm_runtime_disable(&pdev->dev); 261 262 return 0; 263 } 264 265 static const struct of_device_id ks_sa_rng_dt_match[] = { 266 { 267 .compatible = "ti,keystone-rng", 268 }, 269 { }, 270 }; 271 MODULE_DEVICE_TABLE(of, ks_sa_rng_dt_match); 272 273 static struct platform_driver ks_sa_rng_driver = { 274 .driver = { 275 .name = "ks-sa-rng", 276 .of_match_table = ks_sa_rng_dt_match, 277 }, 278 .probe = ks_sa_rng_probe, 279 .remove = ks_sa_rng_remove, 280 }; 281 282 module_platform_driver(ks_sa_rng_driver); 283 284 MODULE_DESCRIPTION("Keystone NETCP SA H/W Random Number Generator driver"); 285 MODULE_AUTHOR("Vitaly Andrianov <vitalya@ti.com>"); 286 MODULE_LICENSE("GPL"); 287