mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-23 12:43:55 +08:00
c81095a465
When reading partitions, the length has to be translated from big endian to the endian order of the host. Similarly, when writing partitions, the length needs to be in big endian order. The userspace tool 'nvram' needs a similar fix as it is reading and writing partitions through /dev/nram : http://sourceforge.net/p/powerpc-utils/mailman/message/31571277/ Signed-off-by: Cedric Le Goater <clg@fr.ibm.com> Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
578 lines
14 KiB
C
578 lines
14 KiB
C
/*
|
|
* c 2001 PPC 64 Team, IBM Corp
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*
|
|
* /dev/nvram driver for PPC64
|
|
*
|
|
* This perhaps should live in drivers/char
|
|
*
|
|
* TODO: Split the /dev/nvram part (that one can use
|
|
* drivers/char/generic_nvram.c) from the arch & partition
|
|
* parsing code.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/miscdevice.h>
|
|
#include <linux/fcntl.h>
|
|
#include <linux/nvram.h>
|
|
#include <linux/init.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/spinlock.h>
|
|
#include <asm/uaccess.h>
|
|
#include <asm/nvram.h>
|
|
#include <asm/rtas.h>
|
|
#include <asm/prom.h>
|
|
#include <asm/machdep.h>
|
|
|
|
#undef DEBUG_NVRAM
|
|
|
|
#define NVRAM_HEADER_LEN sizeof(struct nvram_header)
|
|
#define NVRAM_BLOCK_LEN NVRAM_HEADER_LEN
|
|
|
|
/* If change this size, then change the size of NVNAME_LEN */
|
|
struct nvram_header {
|
|
unsigned char signature;
|
|
unsigned char checksum;
|
|
unsigned short length;
|
|
/* Terminating null required only for names < 12 chars. */
|
|
char name[12];
|
|
};
|
|
|
|
struct nvram_partition {
|
|
struct list_head partition;
|
|
struct nvram_header header;
|
|
unsigned int index;
|
|
};
|
|
|
|
static LIST_HEAD(nvram_partitions);
|
|
|
|
static loff_t dev_nvram_llseek(struct file *file, loff_t offset, int origin)
|
|
{
|
|
int size;
|
|
|
|
if (ppc_md.nvram_size == NULL)
|
|
return -ENODEV;
|
|
size = ppc_md.nvram_size();
|
|
|
|
switch (origin) {
|
|
case 1:
|
|
offset += file->f_pos;
|
|
break;
|
|
case 2:
|
|
offset += size;
|
|
break;
|
|
}
|
|
if (offset < 0)
|
|
return -EINVAL;
|
|
file->f_pos = offset;
|
|
return file->f_pos;
|
|
}
|
|
|
|
|
|
static ssize_t dev_nvram_read(struct file *file, char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
ssize_t ret;
|
|
char *tmp = NULL;
|
|
ssize_t size;
|
|
|
|
if (!ppc_md.nvram_size) {
|
|
ret = -ENODEV;
|
|
goto out;
|
|
}
|
|
|
|
size = ppc_md.nvram_size();
|
|
if (size < 0) {
|
|
ret = size;
|
|
goto out;
|
|
}
|
|
|
|
if (*ppos >= size) {
|
|
ret = 0;
|
|
goto out;
|
|
}
|
|
|
|
count = min_t(size_t, count, size - *ppos);
|
|
count = min(count, PAGE_SIZE);
|
|
|
|
tmp = kmalloc(count, GFP_KERNEL);
|
|
if (!tmp) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
ret = ppc_md.nvram_read(tmp, count, ppos);
|
|
if (ret <= 0)
|
|
goto out;
|
|
|
|
if (copy_to_user(buf, tmp, ret))
|
|
ret = -EFAULT;
|
|
|
|
out:
|
|
kfree(tmp);
|
|
return ret;
|
|
|
|
}
|
|
|
|
static ssize_t dev_nvram_write(struct file *file, const char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
ssize_t ret;
|
|
char *tmp = NULL;
|
|
ssize_t size;
|
|
|
|
ret = -ENODEV;
|
|
if (!ppc_md.nvram_size)
|
|
goto out;
|
|
|
|
ret = 0;
|
|
size = ppc_md.nvram_size();
|
|
if (*ppos >= size || size < 0)
|
|
goto out;
|
|
|
|
count = min_t(size_t, count, size - *ppos);
|
|
count = min(count, PAGE_SIZE);
|
|
|
|
ret = -ENOMEM;
|
|
tmp = kmalloc(count, GFP_KERNEL);
|
|
if (!tmp)
|
|
goto out;
|
|
|
|
ret = -EFAULT;
|
|
if (copy_from_user(tmp, buf, count))
|
|
goto out;
|
|
|
|
ret = ppc_md.nvram_write(tmp, count, ppos);
|
|
|
|
out:
|
|
kfree(tmp);
|
|
return ret;
|
|
|
|
}
|
|
|
|
static long dev_nvram_ioctl(struct file *file, unsigned int cmd,
|
|
unsigned long arg)
|
|
{
|
|
switch(cmd) {
|
|
#ifdef CONFIG_PPC_PMAC
|
|
case OBSOLETE_PMAC_NVRAM_GET_OFFSET:
|
|
printk(KERN_WARNING "nvram: Using obsolete PMAC_NVRAM_GET_OFFSET ioctl\n");
|
|
case IOC_NVRAM_GET_OFFSET: {
|
|
int part, offset;
|
|
|
|
if (!machine_is(powermac))
|
|
return -EINVAL;
|
|
if (copy_from_user(&part, (void __user*)arg, sizeof(part)) != 0)
|
|
return -EFAULT;
|
|
if (part < pmac_nvram_OF || part > pmac_nvram_NR)
|
|
return -EINVAL;
|
|
offset = pmac_get_partition(part);
|
|
if (offset < 0)
|
|
return offset;
|
|
if (copy_to_user((void __user*)arg, &offset, sizeof(offset)) != 0)
|
|
return -EFAULT;
|
|
return 0;
|
|
}
|
|
#endif /* CONFIG_PPC_PMAC */
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
const struct file_operations nvram_fops = {
|
|
.owner = THIS_MODULE,
|
|
.llseek = dev_nvram_llseek,
|
|
.read = dev_nvram_read,
|
|
.write = dev_nvram_write,
|
|
.unlocked_ioctl = dev_nvram_ioctl,
|
|
};
|
|
|
|
static struct miscdevice nvram_dev = {
|
|
NVRAM_MINOR,
|
|
"nvram",
|
|
&nvram_fops
|
|
};
|
|
|
|
|
|
#ifdef DEBUG_NVRAM
|
|
static void __init nvram_print_partitions(char * label)
|
|
{
|
|
struct nvram_partition * tmp_part;
|
|
|
|
printk(KERN_WARNING "--------%s---------\n", label);
|
|
printk(KERN_WARNING "indx\t\tsig\tchks\tlen\tname\n");
|
|
list_for_each_entry(tmp_part, &nvram_partitions, partition) {
|
|
printk(KERN_WARNING "%4d \t%02x\t%02x\t%d\t%12s\n",
|
|
tmp_part->index, tmp_part->header.signature,
|
|
tmp_part->header.checksum, tmp_part->header.length,
|
|
tmp_part->header.name);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
static int __init nvram_write_header(struct nvram_partition * part)
|
|
{
|
|
loff_t tmp_index;
|
|
int rc;
|
|
struct nvram_header phead;
|
|
|
|
memcpy(&phead, &part->header, NVRAM_HEADER_LEN);
|
|
phead.length = cpu_to_be16(phead.length);
|
|
|
|
tmp_index = part->index;
|
|
rc = ppc_md.nvram_write((char *)&phead, NVRAM_HEADER_LEN, &tmp_index);
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
static unsigned char __init nvram_checksum(struct nvram_header *p)
|
|
{
|
|
unsigned int c_sum, c_sum2;
|
|
unsigned short *sp = (unsigned short *)p->name; /* assume 6 shorts */
|
|
c_sum = p->signature + p->length + sp[0] + sp[1] + sp[2] + sp[3] + sp[4] + sp[5];
|
|
|
|
/* The sum may have spilled into the 3rd byte. Fold it back. */
|
|
c_sum = ((c_sum & 0xffff) + (c_sum >> 16)) & 0xffff;
|
|
/* The sum cannot exceed 2 bytes. Fold it into a checksum */
|
|
c_sum2 = (c_sum >> 8) + (c_sum << 8);
|
|
c_sum = ((c_sum + c_sum2) >> 8) & 0xff;
|
|
return c_sum;
|
|
}
|
|
|
|
/*
|
|
* Per the criteria passed via nvram_remove_partition(), should this
|
|
* partition be removed? 1=remove, 0=keep
|
|
*/
|
|
static int nvram_can_remove_partition(struct nvram_partition *part,
|
|
const char *name, int sig, const char *exceptions[])
|
|
{
|
|
if (part->header.signature != sig)
|
|
return 0;
|
|
if (name) {
|
|
if (strncmp(name, part->header.name, 12))
|
|
return 0;
|
|
} else if (exceptions) {
|
|
const char **except;
|
|
for (except = exceptions; *except; except++) {
|
|
if (!strncmp(*except, part->header.name, 12))
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* nvram_remove_partition - Remove one or more partitions in nvram
|
|
* @name: name of the partition to remove, or NULL for a
|
|
* signature only match
|
|
* @sig: signature of the partition(s) to remove
|
|
* @exceptions: When removing all partitions with a matching signature,
|
|
* leave these alone.
|
|
*/
|
|
|
|
int __init nvram_remove_partition(const char *name, int sig,
|
|
const char *exceptions[])
|
|
{
|
|
struct nvram_partition *part, *prev, *tmp;
|
|
int rc;
|
|
|
|
list_for_each_entry(part, &nvram_partitions, partition) {
|
|
if (!nvram_can_remove_partition(part, name, sig, exceptions))
|
|
continue;
|
|
|
|
/* Make partition a free partition */
|
|
part->header.signature = NVRAM_SIG_FREE;
|
|
strncpy(part->header.name, "wwwwwwwwwwww", 12);
|
|
part->header.checksum = nvram_checksum(&part->header);
|
|
rc = nvram_write_header(part);
|
|
if (rc <= 0) {
|
|
printk(KERN_ERR "nvram_remove_partition: nvram_write failed (%d)\n", rc);
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
/* Merge contiguous ones */
|
|
prev = NULL;
|
|
list_for_each_entry_safe(part, tmp, &nvram_partitions, partition) {
|
|
if (part->header.signature != NVRAM_SIG_FREE) {
|
|
prev = NULL;
|
|
continue;
|
|
}
|
|
if (prev) {
|
|
prev->header.length += part->header.length;
|
|
prev->header.checksum = nvram_checksum(&part->header);
|
|
rc = nvram_write_header(part);
|
|
if (rc <= 0) {
|
|
printk(KERN_ERR "nvram_remove_partition: nvram_write failed (%d)\n", rc);
|
|
return rc;
|
|
}
|
|
list_del(&part->partition);
|
|
kfree(part);
|
|
} else
|
|
prev = part;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* nvram_create_partition - Create a partition in nvram
|
|
* @name: name of the partition to create
|
|
* @sig: signature of the partition to create
|
|
* @req_size: size of data to allocate in bytes
|
|
* @min_size: minimum acceptable size (0 means req_size)
|
|
*
|
|
* Returns a negative error code or a positive nvram index
|
|
* of the beginning of the data area of the newly created
|
|
* partition. If you provided a min_size smaller than req_size
|
|
* you need to query for the actual size yourself after the
|
|
* call using nvram_partition_get_size().
|
|
*/
|
|
loff_t __init nvram_create_partition(const char *name, int sig,
|
|
int req_size, int min_size)
|
|
{
|
|
struct nvram_partition *part;
|
|
struct nvram_partition *new_part;
|
|
struct nvram_partition *free_part = NULL;
|
|
static char nv_init_vals[16];
|
|
loff_t tmp_index;
|
|
long size = 0;
|
|
int rc;
|
|
|
|
/* Convert sizes from bytes to blocks */
|
|
req_size = _ALIGN_UP(req_size, NVRAM_BLOCK_LEN) / NVRAM_BLOCK_LEN;
|
|
min_size = _ALIGN_UP(min_size, NVRAM_BLOCK_LEN) / NVRAM_BLOCK_LEN;
|
|
|
|
/* If no minimum size specified, make it the same as the
|
|
* requested size
|
|
*/
|
|
if (min_size == 0)
|
|
min_size = req_size;
|
|
if (min_size > req_size)
|
|
return -EINVAL;
|
|
|
|
/* Now add one block to each for the header */
|
|
req_size += 1;
|
|
min_size += 1;
|
|
|
|
/* Find a free partition that will give us the maximum needed size
|
|
If can't find one that will give us the minimum size needed */
|
|
list_for_each_entry(part, &nvram_partitions, partition) {
|
|
if (part->header.signature != NVRAM_SIG_FREE)
|
|
continue;
|
|
|
|
if (part->header.length >= req_size) {
|
|
size = req_size;
|
|
free_part = part;
|
|
break;
|
|
}
|
|
if (part->header.length > size &&
|
|
part->header.length >= min_size) {
|
|
size = part->header.length;
|
|
free_part = part;
|
|
}
|
|
}
|
|
if (!size)
|
|
return -ENOSPC;
|
|
|
|
/* Create our OS partition */
|
|
new_part = kmalloc(sizeof(*new_part), GFP_KERNEL);
|
|
if (!new_part) {
|
|
pr_err("nvram_create_os_partition: kmalloc failed\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
new_part->index = free_part->index;
|
|
new_part->header.signature = sig;
|
|
new_part->header.length = size;
|
|
strncpy(new_part->header.name, name, 12);
|
|
new_part->header.checksum = nvram_checksum(&new_part->header);
|
|
|
|
rc = nvram_write_header(new_part);
|
|
if (rc <= 0) {
|
|
pr_err("nvram_create_os_partition: nvram_write_header "
|
|
"failed (%d)\n", rc);
|
|
return rc;
|
|
}
|
|
list_add_tail(&new_part->partition, &free_part->partition);
|
|
|
|
/* Adjust or remove the partition we stole the space from */
|
|
if (free_part->header.length > size) {
|
|
free_part->index += size * NVRAM_BLOCK_LEN;
|
|
free_part->header.length -= size;
|
|
free_part->header.checksum = nvram_checksum(&free_part->header);
|
|
rc = nvram_write_header(free_part);
|
|
if (rc <= 0) {
|
|
pr_err("nvram_create_os_partition: nvram_write_header "
|
|
"failed (%d)\n", rc);
|
|
return rc;
|
|
}
|
|
} else {
|
|
list_del(&free_part->partition);
|
|
kfree(free_part);
|
|
}
|
|
|
|
/* Clear the new partition */
|
|
for (tmp_index = new_part->index + NVRAM_HEADER_LEN;
|
|
tmp_index < ((size - 1) * NVRAM_BLOCK_LEN);
|
|
tmp_index += NVRAM_BLOCK_LEN) {
|
|
rc = ppc_md.nvram_write(nv_init_vals, NVRAM_BLOCK_LEN, &tmp_index);
|
|
if (rc <= 0) {
|
|
pr_err("nvram_create_partition: nvram_write failed (%d)\n", rc);
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
return new_part->index + NVRAM_HEADER_LEN;
|
|
}
|
|
|
|
/**
|
|
* nvram_get_partition_size - Get the data size of an nvram partition
|
|
* @data_index: This is the offset of the start of the data of
|
|
* the partition. The same value that is returned by
|
|
* nvram_create_partition().
|
|
*/
|
|
int nvram_get_partition_size(loff_t data_index)
|
|
{
|
|
struct nvram_partition *part;
|
|
|
|
list_for_each_entry(part, &nvram_partitions, partition) {
|
|
if (part->index + NVRAM_HEADER_LEN == data_index)
|
|
return (part->header.length - 1) * NVRAM_BLOCK_LEN;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
/**
|
|
* nvram_find_partition - Find an nvram partition by signature and name
|
|
* @name: Name of the partition or NULL for any name
|
|
* @sig: Signature to test against
|
|
* @out_size: if non-NULL, returns the size of the data part of the partition
|
|
*/
|
|
loff_t nvram_find_partition(const char *name, int sig, int *out_size)
|
|
{
|
|
struct nvram_partition *p;
|
|
|
|
list_for_each_entry(p, &nvram_partitions, partition) {
|
|
if (p->header.signature == sig &&
|
|
(!name || !strncmp(p->header.name, name, 12))) {
|
|
if (out_size)
|
|
*out_size = (p->header.length - 1) *
|
|
NVRAM_BLOCK_LEN;
|
|
return p->index + NVRAM_HEADER_LEN;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int __init nvram_scan_partitions(void)
|
|
{
|
|
loff_t cur_index = 0;
|
|
struct nvram_header phead;
|
|
struct nvram_partition * tmp_part;
|
|
unsigned char c_sum;
|
|
char * header;
|
|
int total_size;
|
|
int err;
|
|
|
|
if (ppc_md.nvram_size == NULL || ppc_md.nvram_size() <= 0)
|
|
return -ENODEV;
|
|
total_size = ppc_md.nvram_size();
|
|
|
|
header = kmalloc(NVRAM_HEADER_LEN, GFP_KERNEL);
|
|
if (!header) {
|
|
printk(KERN_ERR "nvram_scan_partitions: Failed kmalloc\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
while (cur_index < total_size) {
|
|
|
|
err = ppc_md.nvram_read(header, NVRAM_HEADER_LEN, &cur_index);
|
|
if (err != NVRAM_HEADER_LEN) {
|
|
printk(KERN_ERR "nvram_scan_partitions: Error parsing "
|
|
"nvram partitions\n");
|
|
goto out;
|
|
}
|
|
|
|
cur_index -= NVRAM_HEADER_LEN; /* nvram_read will advance us */
|
|
|
|
memcpy(&phead, header, NVRAM_HEADER_LEN);
|
|
|
|
phead.length = be16_to_cpu(phead.length);
|
|
|
|
err = 0;
|
|
c_sum = nvram_checksum(&phead);
|
|
if (c_sum != phead.checksum) {
|
|
printk(KERN_WARNING "WARNING: nvram partition checksum"
|
|
" was %02x, should be %02x!\n",
|
|
phead.checksum, c_sum);
|
|
printk(KERN_WARNING "Terminating nvram partition scan\n");
|
|
goto out;
|
|
}
|
|
if (!phead.length) {
|
|
printk(KERN_WARNING "WARNING: nvram corruption "
|
|
"detected: 0-length partition\n");
|
|
goto out;
|
|
}
|
|
tmp_part = kmalloc(sizeof(struct nvram_partition), GFP_KERNEL);
|
|
err = -ENOMEM;
|
|
if (!tmp_part) {
|
|
printk(KERN_ERR "nvram_scan_partitions: kmalloc failed\n");
|
|
goto out;
|
|
}
|
|
|
|
memcpy(&tmp_part->header, &phead, NVRAM_HEADER_LEN);
|
|
tmp_part->index = cur_index;
|
|
list_add_tail(&tmp_part->partition, &nvram_partitions);
|
|
|
|
cur_index += phead.length * NVRAM_BLOCK_LEN;
|
|
}
|
|
err = 0;
|
|
|
|
#ifdef DEBUG_NVRAM
|
|
nvram_print_partitions("NVRAM Partitions");
|
|
#endif
|
|
|
|
out:
|
|
kfree(header);
|
|
return err;
|
|
}
|
|
|
|
static int __init nvram_init(void)
|
|
{
|
|
int rc;
|
|
|
|
BUILD_BUG_ON(NVRAM_BLOCK_LEN != 16);
|
|
|
|
if (ppc_md.nvram_size == NULL || ppc_md.nvram_size() <= 0)
|
|
return -ENODEV;
|
|
|
|
rc = misc_register(&nvram_dev);
|
|
if (rc != 0) {
|
|
printk(KERN_ERR "nvram_init: failed to register device\n");
|
|
return rc;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
void __exit nvram_cleanup(void)
|
|
{
|
|
misc_deregister( &nvram_dev );
|
|
}
|
|
|
|
module_init(nvram_init);
|
|
module_exit(nvram_cleanup);
|
|
MODULE_LICENSE("GPL");
|