/******************************************************************************
* Copyright (c) 2004, 2008 IBM Corporation
* All rights reserved.
* This program and the accompanying materials
* are made available under the terms of the BSD License
* which accompanies this distribution, and is available at
* http://www.opensource.org/licenses/bsd-license.php
*
* Contributors:
* IBM Corporation - initial implementation
*****************************************************************************/
#include "macros.h"
#include "romfs.h"
/*******************************************************************
* Wrapper for romfs_lookup.
*
* Input:
* R3 = address of filename string
* R4 = address of struct romfs_t
* 0: file size (return)
* 8: flags (return)
* 10: fileaddr (return and input: tells if first search)
* 18: nextfile (return)
* 20: namep (return)
*
* Find File Procedure
* - set filename and rombase, on return 0 file properties are stored
* in romfs_t else struct not valid
*
* Listing procedure
* - clear romfs_t (important!)
* - set filename = NULL and rombase and call returns first file
* with properties in romfs_t including next-file pointer
* - if nextpointer is non-zero then just the next file is returned
*
* Returns:
* <Success>:
* R3 = 0
* romfs_t is updated
* <FileNotFound>:
* R3 = 1
* romfs_t not touched
*
* Potentially modifies the following registers:
*
Example usage from C:
int list_bootrom()
{
struct romfs_t rfs;
int i;
printf("Build: "__TIME__" "__DATE__" \n");
i = 0;
memset((void*) &rfs, 0, sizeof(struct romfs_t));
printf(" No. File Data Size Name\n");
while (romfs_stat(NULL, &rfs) == 0) {
i++;
printf(" %02d: %08X %08X %7d %s\n",
i, rfs.fileaddr, rfs.datap,
rfs.size, rfs.namep);
}
if (0 == i) {
printf("Error in reading ROMFS\n");
return 1;
}
return 0;
}
*******************************************************************/
#define RFS_T_SIZE 0x00
#define RFS_T_FLAGS 0x08
#define RFS_T_FILEADDR 0x10
#define RFS_T_NEXT 0x18
#define RFS_T_NAME 0x20
#define RFS_T_DATA 0x28
#define RFS_H_NEXT 0x00
#define RFS_H_SIZE 0x08
#define RFS_H_FLAGS 0x10
#define RFS_H_DATA 0x18
#define RFS_H_NAME 0x20
ENTRY(romfs_stat_file)
/* save link register and romfs_t pointer */
mflr r15
mr r16, r4
/* if filename R3 is 0 then its a listing request */
/* if not then just continue to lookup name */
/* save R4 to R8 which is the address of header */
li r7, 0
cmpd r3, r7
beq romfs_list
bl romfs_lookup
mfsprg r8, 1
/* if file found then go to romfs_fill_properties */
/* else return 1 to caller */
cmpwi r3, 0
beq romfs_fill_properties
b romfs_stat_end
romfs_list:
/* check if fileaddr == 0, in this case its */
/* the first search on this handle, so return all */
/* info for file at rombase (R8=R4) */
ld r6, RFS_T_FILEADDR(r4)
mfsprg r8, 1
li r7, 0
cmpd r7, r6
beq romfs_fill_properties
/* check if next file != 0 by looking into */
/* romfs_t, if not then return (next = 0) 1 */
li r7, 0
ld r4, RFS_T_NEXT(r4)
cmpd r7, r4
li r3, 1
beq romfs_stat_end
/* now next file is available so move R8 to next */
/* file address */
mr r8, r4
romfs_fill_properties:
/* set properties in romfs_t takes R8 as address */
/* to file header and R16 as address of romfs_t */
mfsprg r3, 1
std r8, RFS_T_FILEADDR(r16)
ld r4, RFS_H_NEXT(r8)
li r7, 0
cmpd r7, r4
beq $ + (2 * 4) /* =0 so add no rombase */
add r4, r4, r3
std r4, RFS_T_NEXT(r16)
ld r4, RFS_H_SIZE(r8)
std r4, RFS_T_SIZE(r16)
ld r4, RFS_H_FLAGS(r8)
std r4, RFS_T_FLAGS(r16)
ld r4, RFS_H_DATA(r8)
add r4, r4, r3
std r4, RFS_T_DATA(r16)
addi r4, r8, RFS_H_NAME
std r4, RFS_T_NAME(r16)
li r3, 0
/* restore romfs_t pointer and link register */
romfs_stat_end:
mr r5, r16
mtlr r15
blr
/*******************************************************************
* Copies the data of file referenced by name string to address
* requires root address of filesystem.
* FIXME: ignores flags
*
* Input:
* R3 = address of filename string
* R4 = ROMBASE
* R5 = destination address
*
* Returns:
* <Success>: R3 = 0, R6 = size, <FileNotFound>: R3 = 1
* R5 is kept
*
* Potentially modifies the following registers:
* ctr, r15, r16, r17, r18
*
* Uses the following calls with subsequent register modification:
* - romfs_lookup
*******************************************************************/
ASM_ENTRY(romfs_load)
mflr r15
/* save R5 twice */
/* lookup file, input regs */
/* are already set */
/* if not found, just return */
mr r16, r5
mr r17, r5
bl romfs_lookup
cmpwi r3, 1
bne 0f
mtlr r15
blr /* abort, not found */
/* save data size for return */
/* found, copy data */
/* data size is in R6 */
0:
//mr r3, r6
mtctr r6
addi r16, r16, -1 /* dest */
addi r5, r5, -1 /* source*/
/* data is expected to be */
/* 8 byte aligned */
/* copy loop */
0: lbzu r18, 1(r5)
stbu r18, 1(r16)
bdnz 0b
/* restore size, keep padding */
/* restore target address */
/* return */
mr r5, r17
mtlr r15
blr
/*******************************************************************
* looks up a file based on filename
*
* Input:
* R3 = address of filename string
* R4 = ROMBASE
*
* Returns:
* <Success>:
* R3 = 0
* R4 = address of file header
* R5 = address of data (real address)
* R6 = size of data
* R7 = flags for file
* <FileNotFound>:
* R3 = 1
*
* Potentially modifies the following registers:
* R3, R4, R5, R6, R7, R8, R9
*
* Uses the following calls with subsequent register modification:
* - romfs_namematch
*******************************************************************/
ASM_ENTRY(romfs_lookup)
mflr r9
romfs_lookup_next:
/* save current file base */
mr r8, r4
/* name to look for */
mr r10, r3
/* name of file */
mr r5, r4
addi r5, r5, (4 /* elems */ * 8 /* elem-size */)
mr r11, r5 /* for namematch */
/* compare */
bl romfs_namematch
cmpwi r12, 1
bne romfs_lookup_match
/* load next pointer */
/* check if next is 0 */
/* apply root-offset */
ld r5, 0(r4)
cmpwi r5, 0
add r4, r4, r5
bne romfs_lookup_next
/* last file reached, abort */
li r3, 1
mtlr r9
blr
/* here the name did match */
/* r4 is still usable here and */
/* pointing to the initial file */
/* load r5 with data ptr */
/* load r6 with data size */
/* load r7 with flags */
/* get abs addr of data */
romfs_lookup_match:
li r3, 0
ld r5, (3 * 8)(r4) /* data */
ld r6, (1 * 8)(r4) /* len */
ld r7, (2 * 8)(r4) /* flags */
add r5, r5, r8
mtlr r9
blr
/*******************************************************************
* compares two strings in memory,
* both must be null-terminated and 8-byte aligned
*
* Input:
* R10 = string 1
* R11 = string 2
*
* Returns:
* <Match>: R12 = 0 <NoMatch>: R12 = 1
*
* Potentially modifies the following registers:
* R10, R11, r12, r13, r14
*******************************************************************/
romfs_namematch:
subi r10, r10, 8
subi r11, r11, 8
/*
* load chars as 8byte chunk from current pos, name is
* always 8 byte aligned :)
*/
romfs_cmp_loop:
ldu r13, 8(r10) /* A */
ldu r14, 8(r11) /* B */
cmpd r13, r14
li r12, 1
beq 1f
blr
1: andi. r14, r14, 0xff
bne romfs_cmp_loop
li r12, 0
blr
/*******************************************************************
* wrapper for romfs_lookup
* this function saves the registers from r13 - r15 on the stack
* calls romfs_lookup
* restores the saved registers
*
* the return parameters are copied to (r5) and (r5) has to
* be 0x20 big
*******************************************************************/
ENTRY(c_romfs_lookup)
stdu r1,-0x50(r1) # allocate space on stack
mflr r0 # save link register
std r0,0x30(r1)
std r15,0x38(r1) # save r15
std r14,0x40(r1) # save r14
std r13,0x48(r1) # and r13
mr r15,r5 # save the pointer for the return value
bl romfs_lookup # do the thing
ld r0,0x30(r1) # restore link register
mtlr r0
std r4,0x00(r15) # copy return values
std r5,0x08(r15) # to the return pointer
std r6,0x10(r15)
std r7,0x18(r15)
ld r13,0x48(r1) # restore registers from stack
ld r14,0x40(r1)
ld r15,0x38(r1)
addi r1,r1,0x50 # cleanup stack
blr