leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[POWERPC] pseries: Force 4k update_flash block and list sizes

Browse Source 
The enablement of 64k pages on pseries platforms exposed a bug in
the RTAS mechanism for updating firmware.  RTAS assumes 4k for flash
block and list sizes, and use of any other sizes results in a failure,
even though PAPR does not specify any such requirement.

This patch changes the rtas_flash module to force the use of 4k memory
block and list sizes when preparing and sending a firmware image to
RTAS.  The rtas_flash function now uses a slab cache of 4k blocks with
4k alignment, rather than get_zeroed_page(), to allocate the memory for
the flash blocks and lists.  The 4k alignment requirement is specified
in PAPR.

Signed-off-by: John Rose <johnrose@austin.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
This commit is contained in:
John Rose 2006-11-08 10:07:30 -06:00 committed by Paul Mackerras
parent 0091cf5a6a
commit ae883cab94
1 changed files with 37 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
arch/powerpc/kernel/rtas_flash.c
View File

@ -72,6 +72,10 @@
#define VALIDATE_BUF_SIZE 4096 #define VALIDATE_BUF_SIZE 4096
#define RTAS_MSG_MAXLEN 64 #define RTAS_MSG_MAXLEN 64
/* Quirk - RTAS requires 4k list length and block size */
#define RTAS_BLKLIST_LENGTH 4096
#define RTAS_BLK_SIZE 4096
struct flash_block { struct flash_block {
char *data; char *data;
unsigned long length; unsigned long length;
@ -83,7 +87,7 @@ struct flash_block {
* into a version/length and translate the pointers * into a version/length and translate the pointers
* to absolute. * to absolute.
*/ */
#define FLASH_BLOCKS_PER_NODE ((PAGE_SIZE - 16) / sizeof(struct flash_block)) #define FLASH_BLOCKS_PER_NODE ((RTAS_BLKLIST_LENGTH - 16) / sizeof(struct flash_block))
struct flash_block_list { struct flash_block_list {
unsigned long num_blocks; unsigned long num_blocks;
struct flash_block_list *next; struct flash_block_list *next;
@ -96,6 +100,9 @@ struct flash_block_list_header { /* just the header of flash_block_list */
static struct flash_block_list_header rtas_firmware_flash_list = {0, NULL}; static struct flash_block_list_header rtas_firmware_flash_list = {0, NULL};
/* Use slab cache to guarantee 4k alignment */
static kmem_cache_t *flash_block_cache = NULL;
#define FLASH_BLOCK_LIST_VERSION (1UL) #define FLASH_BLOCK_LIST_VERSION (1UL)
/* Local copy of the flash block list. /* Local copy of the flash block list.
@ -153,7 +160,7 @@ static int flash_list_valid(struct flash_block_list *flist)
return FLASH_IMG_NULL_DATA; return FLASH_IMG_NULL_DATA;
} }
block_size = f->blocks[i].length; block_size = f->blocks[i].length;
if (block_size <= 0 || block_size > PAGE_SIZE) { if (block_size <= 0 || block_size > RTAS_BLK_SIZE) {
return FLASH_IMG_BAD_LEN; return FLASH_IMG_BAD_LEN;
} }
image_size += block_size; image_size += block_size;
@ -177,9 +184,9 @@ static void free_flash_list(struct flash_block_list *f)
while (f) { while (f) {
for (i = 0; i < f->num_blocks; i++) for (i = 0; i < f->num_blocks; i++)
free_page((unsigned long)(f->blocks[i].data)); kmem_cache_free(flash_block_cache, f->blocks[i].data);
next = f->next; next = f->next;
free_page((unsigned long)f); kmem_cache_free(flash_block_cache, f);
f = next; f = next;
} }
} }
@ -278,6 +285,12 @@ static ssize_t rtas_flash_read(struct file *file, char __user *buf,
return msglen; return msglen;
} }
/* constructor for flash_block_cache */
void rtas_block_ctor(void *ptr, kmem_cache_t *cache, unsigned long flags)
{
memset(ptr, 0, RTAS_BLK_SIZE);
}
/* We could be much more efficient here. But to keep this function /* We could be much more efficient here. But to keep this function
* simple we allocate a page to the block list no matter how small the * simple we allocate a page to the block list no matter how small the
* count is. If the system is low on memory it will be just as well * count is. If the system is low on memory it will be just as well
@ -302,7 +315,7 @@ static ssize_t rtas_flash_write(struct file *file, const char __user *buffer,
* proc file * proc file
*/ */
if (uf->flist == NULL) { if (uf->flist == NULL) {
uf->flist = (struct flash_block_list *) get_zeroed_page(GFP_KERNEL); uf->flist = kmem_cache_alloc(flash_block_cache, GFP_KERNEL);
if (!uf->flist) if (!uf->flist)
return -ENOMEM; return -ENOMEM;
} }
@ -313,21 +326,21 @@ static ssize_t rtas_flash_write(struct file *file, const char __user *buffer,
next_free = fl->num_blocks; next_free = fl->num_blocks;
if (next_free == FLASH_BLOCKS_PER_NODE) { if (next_free == FLASH_BLOCKS_PER_NODE) {
/* Need to allocate another block_list */ /* Need to allocate another block_list */
fl->next = (struct flash_block_list *)get_zeroed_page(GFP_KERNEL); fl->next = kmem_cache_alloc(flash_block_cache, GFP_KERNEL);
if (!fl->next) if (!fl->next)
return -ENOMEM; return -ENOMEM;
fl = fl->next; fl = fl->next;
next_free = 0; next_free = 0;
} }
if (count > PAGE_SIZE) if (count > RTAS_BLK_SIZE)
count = PAGE_SIZE; count = RTAS_BLK_SIZE;
p = (char *)get_zeroed_page(GFP_KERNEL); p = kmem_cache_alloc(flash_block_cache, GFP_KERNEL);
if (!p) if (!p)
return -ENOMEM; return -ENOMEM;
if(copy_from_user(p, buffer, count)) { if(copy_from_user(p, buffer, count)) {
free_page((unsigned long)p); kmem_cache_free(flash_block_cache, p);
return -EFAULT; return -EFAULT;
} }
fl->blocks[next_free].data = p; fl->blocks[next_free].data = p;
@ -791,6 +804,16 @@ int __init rtas_flash_init(void)
goto cleanup; goto cleanup;
rtas_flash_term_hook = rtas_flash_firmware; rtas_flash_term_hook = rtas_flash_firmware;
flash_block_cache = kmem_cache_create("rtas_flash_cache",
RTAS_BLK_SIZE, RTAS_BLK_SIZE, 0,
rtas_block_ctor, NULL);
if (!flash_block_cache) {
printk(KERN_ERR "%s: failed to create block cache\n",
__FUNCTION__);
rc = -ENOMEM;
goto cleanup;
}
return 0; return 0;
cleanup: cleanup:
@ -805,6 +828,10 @@ cleanup:
void __exit rtas_flash_cleanup(void) void __exit rtas_flash_cleanup(void)
{ {
rtas_flash_term_hook = NULL; rtas_flash_term_hook = NULL;
if (flash_block_cache)
kmem_cache_destroy(flash_block_cache);
remove_flash_pde(firmware_flash_pde); remove_flash_pde(firmware_flash_pde);
remove_flash_pde(firmware_update_pde); remove_flash_pde(firmware_update_pde);
remove_flash_pde(validate_pde); remove_flash_pde(validate_pde);