1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (c) ???? Jochen Schäuble <psionic@psionic.de>
4 * Copyright (c) 2003-2004 Joern Engel <joern@wh.fh-wedel.de>
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.
16 * phram=swap,64Mi,128Mi phram=test,900Mi,1Mi,64Ki
19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
31 struct phram_mtd_list {
33 struct list_head list;
36 static LIST_HEAD(phram_list);
38 static int phram_erase(struct mtd_info *mtd, struct erase_info *instr)
40 u_char *start = mtd->priv;
42 memset(start + instr->addr, 0xff, instr->len);
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)
50 *virt = mtd->priv + from;
55 static int phram_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
60 static int phram_read(struct mtd_info *mtd, loff_t from, size_t len,
61 size_t *retlen, u_char *buf)
63 u_char *start = mtd->priv;
65 memcpy(buf, start + from, len);
70 static int phram_write(struct mtd_info *mtd, loff_t to, size_t len,
71 size_t *retlen, const u_char *buf)
73 u_char *start = mtd->priv;
75 memcpy(start + to, buf, len);
80 static void unregister_devices(void)
82 struct phram_mtd_list *this, *safe;
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);
92 static int register_device(char *name, phys_addr_t start, size_t len, uint32_t erasesize)
94 struct phram_mtd_list *new;
97 new = kzalloc(sizeof(*new), GFP_KERNEL);
102 new->mtd.priv = ioremap(start, len);
103 if (!new->mtd.priv) {
104 pr_err("ioremap failed\n");
109 new->mtd.name = name;
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;
123 if (mtd_device_register(&new->mtd, NULL, 0)) {
124 pr_err("Failed to register new device\n");
128 list_add_tail(&new->list, &phram_list);
132 iounmap(new->mtd.priv);
139 static int parse_num64(uint64_t *num64, char *token)
146 /* By dwmw2 editorial decree, "ki", "Mi" or "Gi" are to be used. */
148 if (token[len - 1] == 'i') {
149 switch (token[len - 2]) {
166 ret = kstrtou64(token, 0, num64);
172 static int parse_name(char **pname, const char *token)
177 len = strlen(token) + 1;
181 name = kstrdup(token, GFP_KERNEL);
190 static inline void kill_final_newline(char *str)
192 char *newline = strrchr(str, '\n');
194 if (newline && !newline[1])
199 #define parse_err(fmt, args...) do { \
200 pr_err(fmt , ## args); \
205 static int phram_init_called;
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
214 static char phram_paramline[64 + 20 + 20 + 20];
217 static int phram_setup(const char *val)
219 char buf[64 + 20 + 20 + 20], *str = buf;
224 uint64_t erasesize = PAGE_SIZE;
228 if (strnlen(val, sizeof(buf)) >= sizeof(buf))
229 parse_err("parameter too long\n");
232 kill_final_newline(str);
234 for (i = 0; i < 4; i++)
235 token[i] = strsep(&str, ",");
238 parse_err("too many arguments\n");
241 parse_err("not enough arguments\n");
243 ret = parse_name(&name, token[0]);
247 ret = parse_num64(&start, token[1]);
249 parse_err("illegal start address\n");
253 ret = parse_num64(&len, token[2]);
255 parse_err("illegal device length\n");
260 ret = parse_num64(&erasesize, token[3]);
262 parse_err("illegal erasesize\n");
267 if (len == 0 || erasesize == 0 || erasesize > len
268 || erasesize > UINT_MAX) {
269 parse_err("illegal erasesize or len\n");
274 div_u64_rem(len, (uint32_t)erasesize, &rem);
276 parse_err("len is not multiple of erasesize\n");
281 ret = register_device(name, start, len, (uint32_t)erasesize);
285 pr_info("%s device: %#llx at %#llx for erasesize %#llx\n", name, len, start, erasesize);
293 static int phram_param_call(const char *val, const struct kernel_param *kp)
296 return phram_setup(val);
299 * If more parameters are later passed in via
300 * /sys/module/phram/parameters/phram
301 * and init_phram() has already been called,
302 * we can parse the argument now.
305 if (phram_init_called)
306 return phram_setup(val);
309 * During early boot stage, we only save the parameters
310 * here. We must parse them later: if the param passed
311 * from kernel boot command line, phram_param_call() is
312 * called so early that it is not possible to resolve
313 * the device (even kmalloc() fails). Defer that work to
317 if (strlen(val) >= sizeof(phram_paramline))
319 strcpy(phram_paramline, val);
325 module_param_call(phram, phram_param_call, NULL, NULL, 0200);
326 MODULE_PARM_DESC(phram, "Memory region to map. \"phram=<name>,<start>,<length>[,<erasesize>]\"");
329 static int __init init_phram(void)
334 if (phram_paramline[0])
335 ret = phram_setup(phram_paramline);
336 phram_init_called = 1;
342 static void __exit cleanup_phram(void)
344 unregister_devices();
347 module_init(init_phram);
348 module_exit(cleanup_phram);
350 MODULE_LICENSE("GPL");
351 MODULE_AUTHOR("Joern Engel <joern@wh.fh-wedel.de>");
352 MODULE_DESCRIPTION("MTD driver for physical RAM");