mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-23 12:43:55 +08:00
64da392ab0
The error handling in the phram driver is pretty bad -- in many places, errors are silently ignored or logged, but then still ignored in the return value. So convert all of the code to pass back the correct return value and log error messages properly (and using the new pr_fmt() helper). If everything does go smoothly, rather than exit silently, dump a helpful info message like pretty much every other MTD driver does. Signed-off-by: Mike Frysinger <vapier@gentoo.org> Acked-by: Joern Engel <joern@logfs.org> Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
302 lines
5.6 KiB
C
302 lines
5.6 KiB
C
/**
|
|
* Copyright (c) ???? Jochen Schäuble <psionic@psionic.de>
|
|
* Copyright (c) 2003-2004 Joern Engel <joern@wh.fh-wedel.de>
|
|
*
|
|
* Usage:
|
|
*
|
|
* one commend line parameter per device, each in the form:
|
|
* phram=<name>,<start>,<len>
|
|
* <name> may be up to 63 characters.
|
|
* <start> and <len> can be octal, decimal or hexadecimal. If followed
|
|
* by "ki", "Mi" or "Gi", the numbers will be interpreted as kilo, mega or
|
|
* gigabytes.
|
|
*
|
|
* Example:
|
|
* phram=swap,64Mi,128Mi phram=test,900Mi,1Mi
|
|
*/
|
|
|
|
#define pr_fmt(fmt) "phram: " fmt
|
|
|
|
#include <asm/io.h>
|
|
#include <linux/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/list.h>
|
|
#include <linux/module.h>
|
|
#include <linux/moduleparam.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/mtd/mtd.h>
|
|
|
|
struct phram_mtd_list {
|
|
struct mtd_info mtd;
|
|
struct list_head list;
|
|
};
|
|
|
|
static LIST_HEAD(phram_list);
|
|
|
|
|
|
static int phram_erase(struct mtd_info *mtd, struct erase_info *instr)
|
|
{
|
|
u_char *start = mtd->priv;
|
|
|
|
if (instr->addr + instr->len > mtd->size)
|
|
return -EINVAL;
|
|
|
|
memset(start + instr->addr, 0xff, instr->len);
|
|
|
|
/* This'll catch a few races. Free the thing before returning :)
|
|
* I don't feel at all ashamed. This kind of thing is possible anyway
|
|
* with flash, but unlikely.
|
|
*/
|
|
|
|
instr->state = MTD_ERASE_DONE;
|
|
|
|
mtd_erase_callback(instr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int phram_point(struct mtd_info *mtd, loff_t from, size_t len,
|
|
size_t *retlen, void **virt, resource_size_t *phys)
|
|
{
|
|
if (from + len > mtd->size)
|
|
return -EINVAL;
|
|
|
|
/* can we return a physical address with this driver? */
|
|
if (phys)
|
|
return -EINVAL;
|
|
|
|
*virt = mtd->priv + from;
|
|
*retlen = len;
|
|
return 0;
|
|
}
|
|
|
|
static void phram_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
|
|
{
|
|
}
|
|
|
|
static int phram_read(struct mtd_info *mtd, loff_t from, size_t len,
|
|
size_t *retlen, u_char *buf)
|
|
{
|
|
u_char *start = mtd->priv;
|
|
|
|
if (from >= mtd->size)
|
|
return -EINVAL;
|
|
|
|
if (len > mtd->size - from)
|
|
len = mtd->size - from;
|
|
|
|
memcpy(buf, start + from, len);
|
|
|
|
*retlen = len;
|
|
return 0;
|
|
}
|
|
|
|
static int phram_write(struct mtd_info *mtd, loff_t to, size_t len,
|
|
size_t *retlen, const u_char *buf)
|
|
{
|
|
u_char *start = mtd->priv;
|
|
|
|
if (to >= mtd->size)
|
|
return -EINVAL;
|
|
|
|
if (len > mtd->size - to)
|
|
len = mtd->size - to;
|
|
|
|
memcpy(start + to, buf, len);
|
|
|
|
*retlen = len;
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
static void unregister_devices(void)
|
|
{
|
|
struct phram_mtd_list *this, *safe;
|
|
|
|
list_for_each_entry_safe(this, safe, &phram_list, list) {
|
|
del_mtd_device(&this->mtd);
|
|
iounmap(this->mtd.priv);
|
|
kfree(this);
|
|
}
|
|
}
|
|
|
|
static int register_device(char *name, unsigned long start, unsigned long len)
|
|
{
|
|
struct phram_mtd_list *new;
|
|
int ret = -ENOMEM;
|
|
|
|
new = kzalloc(sizeof(*new), GFP_KERNEL);
|
|
if (!new)
|
|
goto out0;
|
|
|
|
ret = -EIO;
|
|
new->mtd.priv = ioremap(start, len);
|
|
if (!new->mtd.priv) {
|
|
pr_err("ioremap failed\n");
|
|
goto out1;
|
|
}
|
|
|
|
|
|
new->mtd.name = name;
|
|
new->mtd.size = len;
|
|
new->mtd.flags = MTD_CAP_RAM;
|
|
new->mtd.erase = phram_erase;
|
|
new->mtd.point = phram_point;
|
|
new->mtd.unpoint = phram_unpoint;
|
|
new->mtd.read = phram_read;
|
|
new->mtd.write = phram_write;
|
|
new->mtd.owner = THIS_MODULE;
|
|
new->mtd.type = MTD_RAM;
|
|
new->mtd.erasesize = PAGE_SIZE;
|
|
new->mtd.writesize = 1;
|
|
|
|
ret = -EAGAIN;
|
|
if (add_mtd_device(&new->mtd)) {
|
|
pr_err("Failed to register new device\n");
|
|
goto out2;
|
|
}
|
|
|
|
list_add_tail(&new->list, &phram_list);
|
|
return 0;
|
|
|
|
out2:
|
|
iounmap(new->mtd.priv);
|
|
out1:
|
|
kfree(new);
|
|
out0:
|
|
return ret;
|
|
}
|
|
|
|
static int ustrtoul(const char *cp, char **endp, unsigned int base)
|
|
{
|
|
unsigned long result = simple_strtoul(cp, endp, base);
|
|
|
|
switch (**endp) {
|
|
case 'G':
|
|
result *= 1024;
|
|
case 'M':
|
|
result *= 1024;
|
|
case 'k':
|
|
result *= 1024;
|
|
/* By dwmw2 editorial decree, "ki", "Mi" or "Gi" are to be used. */
|
|
if ((*endp)[1] == 'i')
|
|
(*endp) += 2;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static int parse_num32(uint32_t *num32, const char *token)
|
|
{
|
|
char *endp;
|
|
unsigned long n;
|
|
|
|
n = ustrtoul(token, &endp, 0);
|
|
if (*endp)
|
|
return -EINVAL;
|
|
|
|
*num32 = n;
|
|
return 0;
|
|
}
|
|
|
|
static int parse_name(char **pname, const char *token)
|
|
{
|
|
size_t len;
|
|
char *name;
|
|
|
|
len = strlen(token) + 1;
|
|
if (len > 64)
|
|
return -ENOSPC;
|
|
|
|
name = kmalloc(len, GFP_KERNEL);
|
|
if (!name)
|
|
return -ENOMEM;
|
|
|
|
strcpy(name, token);
|
|
|
|
*pname = name;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static inline void kill_final_newline(char *str)
|
|
{
|
|
char *newline = strrchr(str, '\n');
|
|
if (newline && !newline[1])
|
|
*newline = 0;
|
|
}
|
|
|
|
|
|
#define parse_err(fmt, args...) do { \
|
|
pr_err(fmt , ## args); \
|
|
return 1; \
|
|
} while (0)
|
|
|
|
static int phram_setup(const char *val, struct kernel_param *kp)
|
|
{
|
|
char buf[64+12+12], *str = buf;
|
|
char *token[3];
|
|
char *name;
|
|
uint32_t start;
|
|
uint32_t len;
|
|
int i, ret;
|
|
|
|
if (strnlen(val, sizeof(buf)) >= sizeof(buf))
|
|
parse_err("parameter too long\n");
|
|
|
|
strcpy(str, val);
|
|
kill_final_newline(str);
|
|
|
|
for (i=0; i<3; i++)
|
|
token[i] = strsep(&str, ",");
|
|
|
|
if (str)
|
|
parse_err("too many arguments\n");
|
|
|
|
if (!token[2])
|
|
parse_err("not enough arguments\n");
|
|
|
|
ret = parse_name(&name, token[0]);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = parse_num32(&start, token[1]);
|
|
if (ret) {
|
|
kfree(name);
|
|
parse_err("illegal start address\n");
|
|
}
|
|
|
|
ret = parse_num32(&len, token[2]);
|
|
if (ret) {
|
|
kfree(name);
|
|
parse_err("illegal device length\n");
|
|
}
|
|
|
|
ret = register_device(name, start, len);
|
|
if (!ret)
|
|
pr_info("%s device: %#x at %#x\n", name, len, start);
|
|
|
|
return ret;
|
|
}
|
|
|
|
module_param_call(phram, phram_setup, NULL, NULL, 000);
|
|
MODULE_PARM_DESC(phram, "Memory region to map. \"phram=<name>,<start>,<length>\"");
|
|
|
|
|
|
static int __init init_phram(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void __exit cleanup_phram(void)
|
|
{
|
|
unregister_devices();
|
|
}
|
|
|
|
module_init(init_phram);
|
|
module_exit(cleanup_phram);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("Joern Engel <joern@wh.fh-wedel.de>");
|
|
MODULE_DESCRIPTION("MTD driver for physical RAM");
|