1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) ???? Jochen Schäuble <psionic@psionic.de> 4 * Copyright (c) 2003-2004 Joern Engel <joern@wh.fh-wedel.de> 5 * 6 * Usage: 7 * 8 * one commend line parameter per device, each in the form: 9 * phram=<name>,<start>,<len>[,<erasesize>] 10 * <name> may be up to 63 characters. 11 * <start>, <len>, and <erasesize> can be octal, decimal or hexadecimal. If followed 12 * by "ki", "Mi" or "Gi", the numbers will be interpreted as kilo, mega or 13 * gigabytes. <erasesize> is optional and defaults to PAGE_SIZE. 14 * 15 * Example: 16 * phram=swap,64Mi,128Mi phram=test,900Mi,1Mi,64Ki 17 */ 18 19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 20 21 #include <linux/io.h> 22 #include <linux/init.h> 23 #include <linux/kernel.h> 24 #include <linux/list.h> 25 #include <linux/module.h> 26 #include <linux/moduleparam.h> 27 #include <linux/slab.h> 28 #include <linux/mtd/mtd.h> 29 #include <asm/div64.h> 30 31 struct phram_mtd_list { 32 struct mtd_info mtd; 33 struct list_head list; 34 }; 35 36 static LIST_HEAD(phram_list); 37 38 static int phram_erase(struct mtd_info *mtd, struct erase_info *instr) 39 { 40 u_char *start = mtd->priv; 41 42 memset(start + instr->addr, 0xff, instr->len); 43 44 return 0; 45 } 46 47 static int phram_point(struct mtd_info *mtd, loff_t from, size_t len, 48 size_t *retlen, void **virt, resource_size_t *phys) 49 { 50 *virt = mtd->priv + from; 51 *retlen = len; 52 return 0; 53 } 54 55 static int phram_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 56 { 57 return 0; 58 } 59 60 static int phram_read(struct mtd_info *mtd, loff_t from, size_t len, 61 size_t *retlen, u_char *buf) 62 { 63 u_char *start = mtd->priv; 64 65 memcpy(buf, start + from, len); 66 *retlen = len; 67 return 0; 68 } 69 70 static int phram_write(struct mtd_info *mtd, loff_t to, size_t len, 71 size_t *retlen, const u_char *buf) 72 { 73 u_char *start = mtd->priv; 74 75 memcpy(start + to, buf, len); 76 *retlen = len; 77 return 0; 78 } 79 80 static void unregister_devices(void) 81 { 82 struct phram_mtd_list *this, *safe; 83 84 list_for_each_entry_safe(this, safe, &phram_list, list) { 85 mtd_device_unregister(&this->mtd); 86 iounmap(this->mtd.priv); 87 kfree(this->mtd.name); 88 kfree(this); 89 } 90 } 91 92 static int register_device(char *name, phys_addr_t start, size_t len, uint32_t erasesize) 93 { 94 struct phram_mtd_list *new; 95 int ret = -ENOMEM; 96 97 new = kzalloc(sizeof(*new), GFP_KERNEL); 98 if (!new) 99 goto out0; 100 101 ret = -EIO; 102 new->mtd.priv = ioremap(start, len); 103 if (!new->mtd.priv) { 104 pr_err("ioremap failed\n"); 105 goto out1; 106 } 107 108 109 new->mtd.name = name; 110 new->mtd.size = len; 111 new->mtd.flags = MTD_CAP_RAM; 112 new->mtd._erase = phram_erase; 113 new->mtd._point = phram_point; 114 new->mtd._unpoint = phram_unpoint; 115 new->mtd._read = phram_read; 116 new->mtd._write = phram_write; 117 new->mtd.owner = THIS_MODULE; 118 new->mtd.type = MTD_RAM; 119 new->mtd.erasesize = erasesize; 120 new->mtd.writesize = 1; 121 122 ret = -EAGAIN; 123 if (mtd_device_register(&new->mtd, NULL, 0)) { 124 pr_err("Failed to register new device\n"); 125 goto out2; 126 } 127 128 list_add_tail(&new->list, &phram_list); 129 return 0; 130 131 out2: 132 iounmap(new->mtd.priv); 133 out1: 134 kfree(new); 135 out0: 136 return ret; 137 } 138 139 static int parse_num64(uint64_t *num64, char *token) 140 { 141 size_t len; 142 int shift = 0; 143 int ret; 144 145 len = strlen(token); 146 /* By dwmw2 editorial decree, "ki", "Mi" or "Gi" are to be used. */ 147 if (len > 2) { 148 if (token[len - 1] == 'i') { 149 switch (token[len - 2]) { 150 case 'G': 151 shift += 10; 152 fallthrough; 153 case 'M': 154 shift += 10; 155 fallthrough; 156 case 'k': 157 shift += 10; 158 token[len - 2] = 0; 159 break; 160 default: 161 return -EINVAL; 162 } 163 } 164 } 165 166 ret = kstrtou64(token, 0, num64); 167 *num64 <<= shift; 168 169 return ret; 170 } 171 172 static int parse_name(char **pname, const char *token) 173 { 174 size_t len; 175 char *name; 176 177 len = strlen(token) + 1; 178 if (len > 64) 179 return -ENOSPC; 180 181 name = kstrdup(token, GFP_KERNEL); 182 if (!name) 183 return -ENOMEM; 184 185 *pname = name; 186 return 0; 187 } 188 189 190 static inline void kill_final_newline(char *str) 191 { 192 char *newline = strrchr(str, '\n'); 193 194 if (newline && !newline[1]) 195 *newline = 0; 196 } 197 198 199 #define parse_err(fmt, args...) do { \ 200 pr_err(fmt , ## args); \ 201 return 1; \ 202 } while (0) 203 204 #ifndef MODULE 205 static int phram_init_called; 206 /* 207 * This shall contain the module parameter if any. It is of the form: 208 * - phram=<device>,<address>,<size>[,<erasesize>] for module case 209 * - phram.phram=<device>,<address>,<size>[,<erasesize>] for built-in case 210 * We leave 64 bytes for the device name, 20 for the address , 20 for the 211 * size and 20 for the erasesize. 212 * Example: phram.phram=rootfs,0xa0000000,512Mi,65536 213 */ 214 static char phram_paramline[64 + 20 + 20 + 20]; 215 #endif 216 217 static int phram_setup(const char *val) 218 { 219 char buf[64 + 20 + 20 + 20], *str = buf; 220 char *token[4]; 221 char *name; 222 uint64_t start; 223 uint64_t len; 224 uint64_t erasesize = PAGE_SIZE; 225 uint32_t rem; 226 int i, ret; 227 228 if (strnlen(val, sizeof(buf)) >= sizeof(buf)) 229 parse_err("parameter too long\n"); 230 231 strcpy(str, val); 232 kill_final_newline(str); 233 234 for (i = 0; i < 4; i++) 235 token[i] = strsep(&str, ","); 236 237 if (str) 238 parse_err("too many arguments\n"); 239 240 if (!token[2]) 241 parse_err("not enough arguments\n"); 242 243 ret = parse_name(&name, token[0]); 244 if (ret) 245 return ret; 246 247 ret = parse_num64(&start, token[1]); 248 if (ret) { 249 parse_err("illegal start address\n"); 250 goto error; 251 } 252 253 ret = parse_num64(&len, token[2]); 254 if (ret) { 255 parse_err("illegal device length\n"); 256 goto error; 257 } 258 259 if (token[3]) { 260 ret = parse_num64(&erasesize, token[3]); 261 if (ret) { 262 parse_err("illegal erasesize\n"); 263 goto error; 264 } 265 } 266 267 if (erasesize) 268 div_u64_rem(len, (uint32_t)erasesize, &rem); 269 270 if (len == 0 || erasesize == 0 || erasesize > len 271 || erasesize > UINT_MAX || rem) { 272 parse_err("illegal erasesize or len\n"); 273 ret = -EINVAL; 274 goto error; 275 } 276 277 ret = register_device(name, start, len, (uint32_t)erasesize); 278 if (ret) 279 goto error; 280 281 pr_info("%s device: %#llx at %#llx for erasesize %#llx\n", name, len, start, erasesize); 282 return 0; 283 284 error: 285 kfree(name); 286 return ret; 287 } 288 289 static int phram_param_call(const char *val, const struct kernel_param *kp) 290 { 291 #ifdef MODULE 292 return phram_setup(val); 293 #else 294 /* 295 * If more parameters are later passed in via 296 * /sys/module/phram/parameters/phram 297 * and init_phram() has already been called, 298 * we can parse the argument now. 299 */ 300 301 if (phram_init_called) 302 return phram_setup(val); 303 304 /* 305 * During early boot stage, we only save the parameters 306 * here. We must parse them later: if the param passed 307 * from kernel boot command line, phram_param_call() is 308 * called so early that it is not possible to resolve 309 * the device (even kmalloc() fails). Defer that work to 310 * phram_setup(). 311 */ 312 313 if (strlen(val) >= sizeof(phram_paramline)) 314 return -ENOSPC; 315 strcpy(phram_paramline, val); 316 317 return 0; 318 #endif 319 } 320 321 module_param_call(phram, phram_param_call, NULL, NULL, 0200); 322 MODULE_PARM_DESC(phram, "Memory region to map. \"phram=<name>,<start>,<length>[,<erasesize>]\""); 323 324 325 static int __init init_phram(void) 326 { 327 int ret = 0; 328 329 #ifndef MODULE 330 if (phram_paramline[0]) 331 ret = phram_setup(phram_paramline); 332 phram_init_called = 1; 333 #endif 334 335 return ret; 336 } 337 338 static void __exit cleanup_phram(void) 339 { 340 unregister_devices(); 341 } 342 343 module_init(init_phram); 344 module_exit(cleanup_phram); 345 346 MODULE_LICENSE("GPL"); 347 MODULE_AUTHOR("Joern Engel <joern@wh.fh-wedel.de>"); 348 MODULE_DESCRIPTION("MTD driver for physical RAM"); 349