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 int i, ret; 226 227 if (strnlen(val, sizeof(buf)) >= sizeof(buf)) 228 parse_err("parameter too long\n"); 229 230 strcpy(str, val); 231 kill_final_newline(str); 232 233 for (i = 0; i < 4; i++) 234 token[i] = strsep(&str, ","); 235 236 if (str) 237 parse_err("too many arguments\n"); 238 239 if (!token[2]) 240 parse_err("not enough arguments\n"); 241 242 ret = parse_name(&name, token[0]); 243 if (ret) 244 return ret; 245 246 ret = parse_num64(&start, token[1]); 247 if (ret) { 248 parse_err("illegal start address\n"); 249 goto error; 250 } 251 252 ret = parse_num64(&len, token[2]); 253 if (ret) { 254 parse_err("illegal device length\n"); 255 goto error; 256 } 257 258 if (token[3]) { 259 ret = parse_num64(&erasesize, token[3]); 260 if (ret) { 261 parse_err("illegal erasesize\n"); 262 goto error; 263 } 264 } 265 266 if (len == 0 || erasesize == 0 || erasesize > len 267 || erasesize > UINT_MAX || do_div(len, (uint32_t)erasesize) != 0) { 268 parse_err("illegal erasesize or len\n"); 269 goto error; 270 } 271 272 ret = register_device(name, start, len, (uint32_t)erasesize); 273 if (ret) 274 goto error; 275 276 pr_info("%s device: %#llx at %#llx for erasesize %#llx\n", name, len, start, erasesize); 277 return 0; 278 279 error: 280 kfree(name); 281 return ret; 282 } 283 284 static int phram_param_call(const char *val, const struct kernel_param *kp) 285 { 286 #ifdef MODULE 287 return phram_setup(val); 288 #else 289 /* 290 * If more parameters are later passed in via 291 * /sys/module/phram/parameters/phram 292 * and init_phram() has already been called, 293 * we can parse the argument now. 294 */ 295 296 if (phram_init_called) 297 return phram_setup(val); 298 299 /* 300 * During early boot stage, we only save the parameters 301 * here. We must parse them later: if the param passed 302 * from kernel boot command line, phram_param_call() is 303 * called so early that it is not possible to resolve 304 * the device (even kmalloc() fails). Defer that work to 305 * phram_setup(). 306 */ 307 308 if (strlen(val) >= sizeof(phram_paramline)) 309 return -ENOSPC; 310 strcpy(phram_paramline, val); 311 312 return 0; 313 #endif 314 } 315 316 module_param_call(phram, phram_param_call, NULL, NULL, 0200); 317 MODULE_PARM_DESC(phram, "Memory region to map. \"phram=<name>,<start>,<length>[,<erasesize>]\""); 318 319 320 static int __init init_phram(void) 321 { 322 int ret = 0; 323 324 #ifndef MODULE 325 if (phram_paramline[0]) 326 ret = phram_setup(phram_paramline); 327 phram_init_called = 1; 328 #endif 329 330 return ret; 331 } 332 333 static void __exit cleanup_phram(void) 334 { 335 unregister_devices(); 336 } 337 338 module_init(init_phram); 339 module_exit(cleanup_phram); 340 341 MODULE_LICENSE("GPL"); 342 MODULE_AUTHOR("Joern Engel <joern@wh.fh-wedel.de>"); 343 MODULE_DESCRIPTION("MTD driver for physical RAM"); 344