1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * caam - Freescale FSL CAAM support for hw_random 4 * 5 * Copyright 2011 Freescale Semiconductor, Inc. 6 * Copyright 2018-2019 NXP 7 * 8 * Based on caamalg.c crypto API driver. 9 * 10 */ 11 12 #include <linux/hw_random.h> 13 #include <linux/completion.h> 14 #include <linux/atomic.h> 15 #include <linux/kfifo.h> 16 17 #include "compat.h" 18 19 #include "regs.h" 20 #include "intern.h" 21 #include "desc_constr.h" 22 #include "jr.h" 23 #include "error.h" 24 25 #define CAAM_RNG_MAX_FIFO_STORE_SIZE 16 26 27 /* 28 * Length of used descriptors, see caam_init_desc() 29 */ 30 #define CAAM_RNG_DESC_LEN (CAAM_CMD_SZ + \ 31 CAAM_CMD_SZ + \ 32 CAAM_CMD_SZ + CAAM_PTR_SZ_MAX) 33 34 /* rng per-device context */ 35 struct caam_rng_ctx { 36 struct hwrng rng; 37 struct device *jrdev; 38 struct device *ctrldev; 39 void *desc_async; 40 void *desc_sync; 41 struct work_struct worker; 42 struct kfifo fifo; 43 }; 44 45 struct caam_rng_job_ctx { 46 struct completion *done; 47 int *err; 48 }; 49 50 static struct caam_rng_ctx *to_caam_rng_ctx(struct hwrng *r) 51 { 52 return (struct caam_rng_ctx *)r->priv; 53 } 54 55 static void caam_rng_done(struct device *jrdev, u32 *desc, u32 err, 56 void *context) 57 { 58 struct caam_rng_job_ctx *jctx = context; 59 60 if (err) 61 *jctx->err = caam_jr_strstatus(jrdev, err); 62 63 complete(jctx->done); 64 } 65 66 static u32 *caam_init_desc(u32 *desc, dma_addr_t dst_dma) 67 { 68 init_job_desc(desc, 0); /* + 1 cmd_sz */ 69 /* Generate random bytes: + 1 cmd_sz */ 70 append_operation(desc, OP_ALG_ALGSEL_RNG | OP_TYPE_CLASS1_ALG | 71 OP_ALG_PR_ON); 72 /* Store bytes: + 1 cmd_sz + caam_ptr_sz */ 73 append_fifo_store(desc, dst_dma, 74 CAAM_RNG_MAX_FIFO_STORE_SIZE, FIFOST_TYPE_RNGSTORE); 75 76 print_hex_dump_debug("rng job desc@: ", DUMP_PREFIX_ADDRESS, 77 16, 4, desc, desc_bytes(desc), 1); 78 79 return desc; 80 } 81 82 static int caam_rng_read_one(struct device *jrdev, 83 void *dst, int len, 84 void *desc, 85 struct completion *done) 86 { 87 dma_addr_t dst_dma; 88 int err, ret = 0; 89 struct caam_rng_job_ctx jctx = { 90 .done = done, 91 .err = &ret, 92 }; 93 94 len = CAAM_RNG_MAX_FIFO_STORE_SIZE; 95 96 dst_dma = dma_map_single(jrdev, dst, len, DMA_FROM_DEVICE); 97 if (dma_mapping_error(jrdev, dst_dma)) { 98 dev_err(jrdev, "unable to map destination memory\n"); 99 return -ENOMEM; 100 } 101 102 init_completion(done); 103 err = caam_jr_enqueue(jrdev, 104 caam_init_desc(desc, dst_dma), 105 caam_rng_done, &jctx); 106 if (err == -EINPROGRESS) { 107 wait_for_completion(done); 108 err = 0; 109 } 110 111 dma_unmap_single(jrdev, dst_dma, len, DMA_FROM_DEVICE); 112 113 return err ?: (ret ?: len); 114 } 115 116 static void caam_rng_fill_async(struct caam_rng_ctx *ctx) 117 { 118 struct scatterlist sg[1]; 119 struct completion done; 120 int len, nents; 121 122 sg_init_table(sg, ARRAY_SIZE(sg)); 123 nents = kfifo_dma_in_prepare(&ctx->fifo, sg, ARRAY_SIZE(sg), 124 CAAM_RNG_MAX_FIFO_STORE_SIZE); 125 if (!nents) 126 return; 127 128 len = caam_rng_read_one(ctx->jrdev, sg_virt(&sg[0]), 129 sg[0].length, 130 ctx->desc_async, 131 &done); 132 if (len < 0) 133 return; 134 135 kfifo_dma_in_finish(&ctx->fifo, len); 136 } 137 138 static void caam_rng_worker(struct work_struct *work) 139 { 140 struct caam_rng_ctx *ctx = container_of(work, struct caam_rng_ctx, 141 worker); 142 caam_rng_fill_async(ctx); 143 } 144 145 static int caam_read(struct hwrng *rng, void *dst, size_t max, bool wait) 146 { 147 struct caam_rng_ctx *ctx = to_caam_rng_ctx(rng); 148 int out; 149 150 if (wait) { 151 struct completion done; 152 153 return caam_rng_read_one(ctx->jrdev, dst, max, 154 ctx->desc_sync, &done); 155 } 156 157 out = kfifo_out(&ctx->fifo, dst, max); 158 if (kfifo_is_empty(&ctx->fifo)) 159 schedule_work(&ctx->worker); 160 161 return out; 162 } 163 164 static void caam_cleanup(struct hwrng *rng) 165 { 166 struct caam_rng_ctx *ctx = to_caam_rng_ctx(rng); 167 168 flush_work(&ctx->worker); 169 caam_jr_free(ctx->jrdev); 170 kfifo_free(&ctx->fifo); 171 } 172 173 static int caam_init(struct hwrng *rng) 174 { 175 struct caam_rng_ctx *ctx = to_caam_rng_ctx(rng); 176 int err; 177 178 ctx->desc_sync = devm_kzalloc(ctx->ctrldev, CAAM_RNG_DESC_LEN, 179 GFP_DMA | GFP_KERNEL); 180 if (!ctx->desc_sync) 181 return -ENOMEM; 182 183 ctx->desc_async = devm_kzalloc(ctx->ctrldev, CAAM_RNG_DESC_LEN, 184 GFP_DMA | GFP_KERNEL); 185 if (!ctx->desc_async) 186 return -ENOMEM; 187 188 if (kfifo_alloc(&ctx->fifo, CAAM_RNG_MAX_FIFO_STORE_SIZE, 189 GFP_DMA | GFP_KERNEL)) 190 return -ENOMEM; 191 192 INIT_WORK(&ctx->worker, caam_rng_worker); 193 194 ctx->jrdev = caam_jr_alloc(); 195 err = PTR_ERR_OR_ZERO(ctx->jrdev); 196 if (err) { 197 kfifo_free(&ctx->fifo); 198 pr_err("Job Ring Device allocation for transform failed\n"); 199 return err; 200 } 201 202 /* 203 * Fill async buffer to have early randomness data for 204 * hw_random 205 */ 206 caam_rng_fill_async(ctx); 207 208 return 0; 209 } 210 211 int caam_rng_init(struct device *ctrldev); 212 213 void caam_rng_exit(struct device *ctrldev) 214 { 215 devres_release_group(ctrldev, caam_rng_init); 216 } 217 218 int caam_rng_init(struct device *ctrldev) 219 { 220 struct caam_rng_ctx *ctx; 221 u32 rng_inst; 222 struct caam_drv_private *priv = dev_get_drvdata(ctrldev); 223 int ret; 224 225 /* Check for an instantiated RNG before registration */ 226 if (priv->era < 10) 227 rng_inst = (rd_reg32(&priv->ctrl->perfmon.cha_num_ls) & 228 CHA_ID_LS_RNG_MASK) >> CHA_ID_LS_RNG_SHIFT; 229 else 230 rng_inst = rd_reg32(&priv->ctrl->vreg.rng) & CHA_VER_NUM_MASK; 231 232 if (!rng_inst) 233 return 0; 234 235 if (!devres_open_group(ctrldev, caam_rng_init, GFP_KERNEL)) 236 return -ENOMEM; 237 238 ctx = devm_kzalloc(ctrldev, sizeof(*ctx), GFP_KERNEL); 239 if (!ctx) 240 return -ENOMEM; 241 242 ctx->ctrldev = ctrldev; 243 244 ctx->rng.name = "rng-caam"; 245 ctx->rng.init = caam_init; 246 ctx->rng.cleanup = caam_cleanup; 247 ctx->rng.read = caam_read; 248 ctx->rng.priv = (unsigned long)ctx; 249 ctx->rng.quality = 1024; 250 251 dev_info(ctrldev, "registering rng-caam\n"); 252 253 ret = devm_hwrng_register(ctrldev, &ctx->rng); 254 if (ret) { 255 caam_rng_exit(ctrldev); 256 return ret; 257 } 258 259 devres_close_group(ctrldev, caam_rng_init); 260 return 0; 261 } 262