cbfs: Move static variables into a struct

At present there are a number of static variables in BSS. This cannot work
with SPL, at least until BSS is available in board_init_r().

Move the variables into a struct, so it is possible to malloc() it and use
it before BSS is available.

Signed-off-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tested-by: Bin Meng <bmeng.cn@gmail.com>

diff --git a/fs/cbfs/cbfs.c b/fs/cbfs/cbfs.c
index 2a9edcc9a002768a46e81c701acb76745b206c9c..daae71629706f45f52d4cb68fbde1102e129af7a 100644 (file)
--- a/fs/cbfs/cbfs.c
+++ b/fs/cbfs/cbfs.c
@@ -11,9 +11,14 @@
 enum cbfs_result file_cbfs_result;
 static const u32 good_magic = 0x4f524243;
 static const u8 good_file_magic[] = "LARCHIVE";
-static int initialized;
-static struct cbfs_header cbfs_header;
-static struct cbfs_cachenode *file_cache;
+
+struct cbfs_priv {
+       int initialized;
+       struct cbfs_header header;
+       struct cbfs_cachenode *file_cache;
+};
+
+static struct cbfs_priv cbfs_s;
 
 const char *file_cbfs_error(void)
 {
@@ -69,8 +74,9 @@ static void swap_file_header(struct cbfs_fileheader *dest,
  *
  * @return 1 if a file is found, 0 if one isn't.
  */
-static int file_cbfs_next_file(u8 *start, u32 size, u32 align,
-                              struct cbfs_cachenode *newNode, u32 *used)
+static int file_cbfs_next_file(struct cbfs_priv *priv, u8 *start, u32 size,
+                              u32 align, struct cbfs_cachenode *newNode,
+                              u32 *used)
 {
        struct cbfs_fileheader header;
 
@@ -117,20 +123,21 @@ static int file_cbfs_next_file(u8 *start, u32 size, u32 align,
 }
 
 /* Look through a CBFS instance and copy file metadata into regular memory. */
-static void file_cbfs_fill_cache(u8 *start, u32 size, u32 align)
+static void file_cbfs_fill_cache(struct cbfs_priv *priv, u8 *start, u32 size,
+                                u32 align)
 {
        struct cbfs_cachenode *cache_node;
        struct cbfs_cachenode *newNode;
-       struct cbfs_cachenode **cache_tail = &file_cache;
+       struct cbfs_cachenode **cache_tail = &priv->file_cache;
 
        /* Clear out old information. */
-       cache_node = file_cache;
+       cache_node = priv->file_cache;
        while (cache_node) {
                struct cbfs_cachenode *oldNode = cache_node;
                cache_node = cache_node->next;
                free(oldNode);
        }
-       file_cache = NULL;
+       priv->file_cache = NULL;
 
        while (size >= align) {
                int result;
@@ -138,8 +145,8 @@ static void file_cbfs_fill_cache(u8 *start, u32 size, u32 align)
 
                newNode = (struct cbfs_cachenode *)
                                malloc(sizeof(struct cbfs_cachenode));
-               result = file_cbfs_next_file(start, size, align,
-                       newNode, &used);
+               result = file_cbfs_next_file(priv, start, size, align, newNode,
+                                            &used);
 
                if (result < 0) {
                        free(newNode);
@@ -175,27 +182,35 @@ static int file_cbfs_load_header(uintptr_t end_of_rom,
        return 0;
 }
 
-void file_cbfs_init(uintptr_t end_of_rom)
+static void cbfs_init(struct cbfs_priv *priv, uintptr_t end_of_rom)
 {
        u8 *start_of_rom;
-       initialized = 0;
 
-       if (file_cbfs_load_header(end_of_rom, &cbfs_header))
+       priv->initialized = 0;
+
+       if (file_cbfs_load_header(end_of_rom, &priv->header))
                return;
 
-       start_of_rom = (u8 *)(end_of_rom + 1 - cbfs_header.rom_size);
+       start_of_rom = (u8 *)(end_of_rom + 1 - priv->header.rom_size);
 
-       file_cbfs_fill_cache(start_of_rom, cbfs_header.rom_size,
-                            cbfs_header.align);
+       file_cbfs_fill_cache(priv, start_of_rom, priv->header.rom_size,
+                            priv->header.align);
        if (file_cbfs_result == CBFS_SUCCESS)
-               initialized = 1;
+               priv->initialized = 1;
+}
+
+void file_cbfs_init(uintptr_t end_of_rom)
+{
+       cbfs_init(&cbfs_s, end_of_rom);
 }
 
 const struct cbfs_header *file_cbfs_get_header(void)
 {
-       if (initialized) {
+       struct cbfs_priv *priv = &cbfs_s;
+
+       if (priv->initialized) {
                file_cbfs_result = CBFS_SUCCESS;
-               return &cbfs_header;
+               return &priv->header;
        } else {
                file_cbfs_result = CBFS_NOT_INITIALIZED;
                return NULL;
@@ -204,20 +219,24 @@ const struct cbfs_header *file_cbfs_get_header(void)
 
 const struct cbfs_cachenode *file_cbfs_get_first(void)
 {
-       if (!initialized) {
+       struct cbfs_priv *priv = &cbfs_s;
+
+       if (!priv->initialized) {
                file_cbfs_result = CBFS_NOT_INITIALIZED;
                return NULL;
        } else {
                file_cbfs_result = CBFS_SUCCESS;
-               return file_cache;
+               return priv->file_cache;
        }
 }
 
 void file_cbfs_get_next(const struct cbfs_cachenode **file)
 {
-       if (!initialized) {
+       struct cbfs_priv *priv = &cbfs_s;
+
+       if (!priv->initialized) {
                file_cbfs_result = CBFS_NOT_INITIALIZED;
-               file = NULL;
+               *file = NULL;
                return;
        }
 
@@ -226,11 +245,12 @@ void file_cbfs_get_next(const struct cbfs_cachenode **file)
        file_cbfs_result = CBFS_SUCCESS;
 }
 
-const struct cbfs_cachenode *file_cbfs_find(const char *name)
+const struct cbfs_cachenode *cbfs_find_file(struct cbfs_priv *priv,
+                                           const char *name)
 {
-       struct cbfs_cachenode *cache_node = file_cache;
+       struct cbfs_cachenode *cache_node = priv->file_cache;
 
-       if (!initialized) {
+       if (!priv->initialized) {
                file_cbfs_result = CBFS_NOT_INITIALIZED;
                return NULL;
        }
@@ -248,26 +268,33 @@ const struct cbfs_cachenode *file_cbfs_find(const char *name)
        return cache_node;
 }
 
+const struct cbfs_cachenode *file_cbfs_find(const char *name)
+{
+       return cbfs_find_file(&cbfs_s, name);
+}
+
 const struct cbfs_cachenode *file_cbfs_find_uncached(uintptr_t end_of_rom,
                                                     const char *name)
 {
+       struct cbfs_priv *priv = &cbfs_s;
        u8 *start;
        u32 size;
        u32 align;
        static struct cbfs_cachenode node;
 
-       if (file_cbfs_load_header(end_of_rom, &cbfs_header))
+       if (file_cbfs_load_header(end_of_rom, &priv->header))
                return NULL;
 
-       start = (u8 *)(end_of_rom + 1 - cbfs_header.rom_size);
-       size = cbfs_header.rom_size;
-       align = cbfs_header.align;
+       start = (u8 *)(end_of_rom + 1 - priv->header.rom_size);
+       size = priv->header.rom_size;
+       align = priv->header.align;
 
        while (size >= align) {
                int result;
                u32 used;
 
-               result = file_cbfs_next_file(start, size, align, &node, &used);
+               result = file_cbfs_next_file(priv, start, size, align, &node,
+                                            &used);
 
                if (result < 0)
                        return NULL;