Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ae883cab authored by John Rose's avatar John Rose Committed by Paul Mackerras
Browse files

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



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: default avatarJohn Rose <johnrose@austin.ibm.com>
Signed-off-by: default avatarPaul Mackerras <paulus@samba.org>
parent 0091cf5a

arch/powerpc/kernel/rtas_flash.c

+37 −10
Original line number Diff line number Diff line
@@ -72,6 +72,10 @@ 
#define VALIDATE_BUF_SIZE 4096    

#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 {

	char *data;

	unsigned long length;
@@ -83,7 +87,7 @@ struct flash_block { 
 * into a version/length and translate the pointers

 * 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 {

	unsigned long num_blocks;

	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};



/* Use slab cache to guarantee 4k alignment */

static kmem_cache_t *flash_block_cache = NULL;



#define FLASH_BLOCK_LIST_VERSION (1UL)



/* 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;

			}

			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;

			}

			image_size += block_size;
@@ -177,9 +184,9 @@ static void free_flash_list(struct flash_block_list *f) 


	while (f) {

		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;

		free_page((unsigned long)f);

		kmem_cache_free(flash_block_cache, f);

		f = next;

	}

}
@@ -278,6 +285,12 @@ static ssize_t rtas_flash_read(struct file *file, char __user *buf, 
	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

 * 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
@@ -302,7 +315,7 @@ static ssize_t rtas_flash_write(struct file *file, const char __user *buffer, 
	 * proc file

	 */

	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)

			return -ENOMEM;

	}
@@ -313,21 +326,21 @@ static ssize_t rtas_flash_write(struct file *file, const char __user *buffer, 
	next_free = fl->num_blocks;

	if (next_free == FLASH_BLOCKS_PER_NODE) {

		/* 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)

			return -ENOMEM;

		fl = fl->next;

		next_free = 0;

	}



	if (count > PAGE_SIZE)

		count = PAGE_SIZE;

	p = (char *)get_zeroed_page(GFP_KERNEL);

	if (count > RTAS_BLK_SIZE)

		count = RTAS_BLK_SIZE;

	p = kmem_cache_alloc(flash_block_cache, GFP_KERNEL);

	if (!p)

		return -ENOMEM;

	

	if(copy_from_user(p, buffer, count)) {

		free_page((unsigned long)p);

		kmem_cache_free(flash_block_cache, p);

		return -EFAULT;

	}

	fl->blocks[next_free].data = p;
@@ -791,6 +804,16 @@ int __init rtas_flash_init(void) 
		goto cleanup;



	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;



cleanup:
@@ -805,6 +828,10 @@ int __init rtas_flash_init(void) 
void __exit rtas_flash_cleanup(void)

{

	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_update_pde);

	remove_flash_pde(validate_pde);