1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * OMAP Crypto driver common support routines. 4 * 5 * Copyright (c) 2017 Texas Instruments Incorporated 6 * Tero Kristo <t-kristo@ti.com> 7 */ 8 9 #include <linux/module.h> 10 #include <linux/kernel.h> 11 #include <linux/scatterlist.h> 12 #include <crypto/scatterwalk.h> 13 14 #include "omap-crypto.h" 15 16 static int omap_crypto_copy_sg_lists(int total, int bs, 17 struct scatterlist **sg, 18 struct scatterlist *new_sg, u16 flags) 19 { 20 int n = sg_nents(*sg); 21 struct scatterlist *tmp; 22 23 if (!(flags & OMAP_CRYPTO_FORCE_SINGLE_ENTRY)) { 24 new_sg = kmalloc_array(n, sizeof(*sg), GFP_KERNEL); 25 if (!new_sg) 26 return -ENOMEM; 27 28 sg_init_table(new_sg, n); 29 } 30 31 tmp = new_sg; 32 33 while (*sg && total) { 34 int len = (*sg)->length; 35 36 if (total < len) 37 len = total; 38 39 if (len > 0) { 40 total -= len; 41 sg_set_page(tmp, sg_page(*sg), len, (*sg)->offset); 42 if (total <= 0) 43 sg_mark_end(tmp); 44 tmp = sg_next(tmp); 45 } 46 47 *sg = sg_next(*sg); 48 } 49 50 *sg = new_sg; 51 52 return 0; 53 } 54 55 static int omap_crypto_copy_sgs(int total, int bs, struct scatterlist **sg, 56 struct scatterlist *new_sg, u16 flags) 57 { 58 void *buf; 59 int pages; 60 int new_len; 61 62 new_len = ALIGN(total, bs); 63 pages = get_order(new_len); 64 65 buf = (void *)__get_free_pages(GFP_ATOMIC, pages); 66 if (!buf) { 67 pr_err("%s: Couldn't allocate pages for unaligned cases.\n", 68 __func__); 69 return -ENOMEM; 70 } 71 72 if (flags & OMAP_CRYPTO_COPY_DATA) { 73 scatterwalk_map_and_copy(buf, *sg, 0, total, 0); 74 if (flags & OMAP_CRYPTO_ZERO_BUF) 75 memset(buf + total, 0, new_len - total); 76 } 77 78 if (!(flags & OMAP_CRYPTO_FORCE_SINGLE_ENTRY)) 79 sg_init_table(new_sg, 1); 80 81 sg_set_buf(new_sg, buf, new_len); 82 83 *sg = new_sg; 84 85 return 0; 86 } 87 88 static int omap_crypto_check_sg(struct scatterlist *sg, int total, int bs, 89 u16 flags) 90 { 91 int len = 0; 92 int num_sg = 0; 93 94 if (!IS_ALIGNED(total, bs)) 95 return OMAP_CRYPTO_NOT_ALIGNED; 96 97 while (sg) { 98 num_sg++; 99 100 if (!IS_ALIGNED(sg->offset, 4)) 101 return OMAP_CRYPTO_NOT_ALIGNED; 102 if (!IS_ALIGNED(sg->length, bs)) 103 return OMAP_CRYPTO_NOT_ALIGNED; 104 #ifdef CONFIG_ZONE_DMA 105 if (page_zonenum(sg_page(sg)) != ZONE_DMA) 106 return OMAP_CRYPTO_NOT_ALIGNED; 107 #endif 108 109 len += sg->length; 110 sg = sg_next(sg); 111 112 if (len >= total) 113 break; 114 } 115 116 if ((flags & OMAP_CRYPTO_FORCE_SINGLE_ENTRY) && num_sg > 1) 117 return OMAP_CRYPTO_NOT_ALIGNED; 118 119 if (len != total) 120 return OMAP_CRYPTO_BAD_DATA_LENGTH; 121 122 return 0; 123 } 124 125 int omap_crypto_align_sg(struct scatterlist **sg, int total, int bs, 126 struct scatterlist *new_sg, u16 flags, 127 u8 flags_shift, unsigned long *dd_flags) 128 { 129 int ret; 130 131 *dd_flags &= ~(OMAP_CRYPTO_COPY_MASK << flags_shift); 132 133 if (flags & OMAP_CRYPTO_FORCE_COPY) 134 ret = OMAP_CRYPTO_NOT_ALIGNED; 135 else 136 ret = omap_crypto_check_sg(*sg, total, bs, flags); 137 138 if (ret == OMAP_CRYPTO_NOT_ALIGNED) { 139 ret = omap_crypto_copy_sgs(total, bs, sg, new_sg, flags); 140 if (ret) 141 return ret; 142 *dd_flags |= OMAP_CRYPTO_DATA_COPIED << flags_shift; 143 } else if (ret == OMAP_CRYPTO_BAD_DATA_LENGTH) { 144 ret = omap_crypto_copy_sg_lists(total, bs, sg, new_sg, flags); 145 if (ret) 146 return ret; 147 if (!(flags & OMAP_CRYPTO_FORCE_SINGLE_ENTRY)) 148 *dd_flags |= OMAP_CRYPTO_SG_COPIED << flags_shift; 149 } else if (flags & OMAP_CRYPTO_FORCE_SINGLE_ENTRY) { 150 sg_set_buf(new_sg, sg_virt(*sg), (*sg)->length); 151 } 152 153 return 0; 154 } 155 EXPORT_SYMBOL_GPL(omap_crypto_align_sg); 156 157 static void omap_crypto_copy_data(struct scatterlist *src, 158 struct scatterlist *dst, 159 int offset, int len) 160 { 161 int amt; 162 void *srcb, *dstb; 163 int srco = 0, dsto = offset; 164 165 while (src && dst && len) { 166 if (srco >= src->length) { 167 srco -= src->length; 168 src = sg_next(src); 169 continue; 170 } 171 172 if (dsto >= dst->length) { 173 dsto -= dst->length; 174 dst = sg_next(dst); 175 continue; 176 } 177 178 amt = min(src->length - srco, dst->length - dsto); 179 amt = min(len, amt); 180 181 srcb = kmap_atomic(sg_page(src)) + srco + src->offset; 182 dstb = kmap_atomic(sg_page(dst)) + dsto + dst->offset; 183 184 memcpy(dstb, srcb, amt); 185 186 flush_dcache_page(sg_page(dst)); 187 188 kunmap_atomic(srcb); 189 kunmap_atomic(dstb); 190 191 srco += amt; 192 dsto += amt; 193 len -= amt; 194 } 195 } 196 197 void omap_crypto_cleanup(struct scatterlist *sg, struct scatterlist *orig, 198 int offset, int len, u8 flags_shift, 199 unsigned long flags) 200 { 201 void *buf; 202 int pages; 203 204 flags >>= flags_shift; 205 flags &= OMAP_CRYPTO_COPY_MASK; 206 207 if (!flags) 208 return; 209 210 buf = sg_virt(sg); 211 pages = get_order(len); 212 213 if (orig && (flags & OMAP_CRYPTO_DATA_COPIED)) 214 omap_crypto_copy_data(sg, orig, offset, len); 215 216 if (flags & OMAP_CRYPTO_DATA_COPIED) 217 free_pages((unsigned long)buf, pages); 218 else if (flags & OMAP_CRYPTO_SG_COPIED) 219 kfree(sg); 220 } 221 EXPORT_SYMBOL_GPL(omap_crypto_cleanup); 222 223 MODULE_DESCRIPTION("OMAP crypto support library."); 224 MODULE_LICENSE("GPL v2"); 225 MODULE_AUTHOR("Tero Kristo <t-kristo@ti.com>"); 226