diff --git a/fs/squashfs/sqfs.c b/fs/squashfs/sqfs.c
index 340e5ebdb9..2836b3de8b 100644
--- a/fs/squashfs/sqfs.c
+++ b/fs/squashfs/sqfs.c
@@ -23,22 +23,16 @@
 #include "sqfs_filesystem.h"
 #include "sqfs_utils.h"
 
-struct squashfs_ctxt {
-	struct disk_partition cur_part_info;
-	struct blk_desc *cur_dev;
-	struct squashfs_super_block *sblk;
-};
-
-static struct squashfs_ctxt ctxt;
+struct squashfs_ctxt sqfs_ctxt;
 
 static int sqfs_disk_read(__u32 block, __u32 nr_blocks, void *buf)
 {
 	ulong ret;
 
-	if (!ctxt.cur_dev)
+	if (!sqfs_ctxt.cur_dev)
 		return -1;
 
-	ret = blk_dread(ctxt.cur_dev, ctxt.cur_part_info.start + block,
+	ret = blk_dread(sqfs_ctxt.cur_dev, sqfs_ctxt.cur_part_info.start + block,
 			nr_blocks, buf);
 
 	if (ret != nr_blocks)
@@ -49,7 +43,7 @@ static int sqfs_disk_read(__u32 block, __u32 nr_blocks, void *buf)
 
 static int sqfs_read_sblk(struct squashfs_super_block **sblk)
 {
-	*sblk = malloc_cache_aligned(ctxt.cur_dev->blksz);
+	*sblk = malloc_cache_aligned(sqfs_ctxt.cur_dev->blksz);
 	if (!*sblk)
 		return -ENOMEM;
 
@@ -91,10 +85,10 @@ static int sqfs_calc_n_blks(__le64 start, __le64 end, u64 *offset)
 	u64 start_, table_size;
 
 	table_size = le64_to_cpu(end) - le64_to_cpu(start);
-	start_ = le64_to_cpu(start) / ctxt.cur_dev->blksz;
-	*offset = le64_to_cpu(start) - (start_ * ctxt.cur_dev->blksz);
+	start_ = le64_to_cpu(start) / sqfs_ctxt.cur_dev->blksz;
+	*offset = le64_to_cpu(start) - (start_ * sqfs_ctxt.cur_dev->blksz);
 
-	return DIV_ROUND_UP(table_size + *offset, ctxt.cur_dev->blksz);
+	return DIV_ROUND_UP(table_size + *offset, sqfs_ctxt.cur_dev->blksz);
 }
 
 /*
@@ -107,7 +101,7 @@ static int sqfs_frag_lookup(u32 inode_fragment_index,
 	u64 start, n_blks, src_len, table_offset, start_block;
 	unsigned char *metadata_buffer, *metadata, *table;
 	struct squashfs_fragment_block_entry *entries;
-	struct squashfs_super_block *sblk = ctxt.sblk;
+	struct squashfs_super_block *sblk = sqfs_ctxt.sblk;
 	unsigned long dest_len;
 	int block, offset, ret;
 	u16 header, comp_type;
@@ -118,13 +112,13 @@ static int sqfs_frag_lookup(u32 inode_fragment_index,
 		return -EINVAL;
 
 	start = get_unaligned_le64(&sblk->fragment_table_start) /
-		ctxt.cur_dev->blksz;
+		sqfs_ctxt.cur_dev->blksz;
 	n_blks = sqfs_calc_n_blks(sblk->fragment_table_start,
 				  sblk->export_table_start,
 				  &table_offset);
 
 	/* Allocate a proper sized buffer to store the fragment index table */
-	table = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
+	table = malloc_cache_aligned(n_blks * sqfs_ctxt.cur_dev->blksz);
 	if (!table)
 		return -ENOMEM;
 
@@ -143,11 +137,11 @@ static int sqfs_frag_lookup(u32 inode_fragment_index,
 	start_block = get_unaligned_le64(table + table_offset + block *
 					 sizeof(u64));
 
-	start = start_block / ctxt.cur_dev->blksz;
+	start = start_block / sqfs_ctxt.cur_dev->blksz;
 	n_blks = sqfs_calc_n_blks(cpu_to_le64(start_block),
 				  sblk->fragment_table_start, &table_offset);
 
-	metadata_buffer = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
+	metadata_buffer = malloc_cache_aligned(n_blks * sqfs_ctxt.cur_dev->blksz);
 	if (!metadata_buffer) {
 		ret = -ENOMEM;
 		goto free_table;
@@ -434,7 +428,7 @@ static char *sqfs_resolve_symlink(struct squashfs_symlink_inode *sym,
 static int sqfs_search_dir(struct squashfs_dir_stream *dirs, char **token_list,
 			   int token_count, u32 *m_list, int m_count)
 {
-	struct squashfs_super_block *sblk = ctxt.sblk;
+	struct squashfs_super_block *sblk = sqfs_ctxt.sblk;
 	char *path, *target, **sym_tokens, *res, *rem;
 	int j, ret, new_inode_number, offset;
 	struct squashfs_symlink_inode *sym;
@@ -633,7 +627,7 @@ static int sqfs_get_metablk_pos(u32 *pos_list, void *table, u32 offset,
 
 static int sqfs_read_inode_table(unsigned char **inode_table)
 {
-	struct squashfs_super_block *sblk = ctxt.sblk;
+	struct squashfs_super_block *sblk = sqfs_ctxt.sblk;
 	u64 start, n_blks, table_offset, table_size;
 	int j, ret = 0, metablks_count, comp_type;
 	unsigned char *src_table, *itb;
@@ -645,12 +639,12 @@ static int sqfs_read_inode_table(unsigned char **inode_table)
 	table_size = get_unaligned_le64(&sblk->directory_table_start) -
 		get_unaligned_le64(&sblk->inode_table_start);
 	start = get_unaligned_le64(&sblk->inode_table_start) /
-		ctxt.cur_dev->blksz;
+		sqfs_ctxt.cur_dev->blksz;
 	n_blks = sqfs_calc_n_blks(sblk->inode_table_start,
 				  sblk->directory_table_start, &table_offset);
 
 	/* Allocate a proper sized buffer (itb) to store the inode table */
-	itb = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
+	itb = malloc_cache_aligned(n_blks * sqfs_ctxt.cur_dev->blksz);
 	if (!itb)
 		return -ENOMEM;
 
@@ -718,7 +712,7 @@ static int sqfs_read_directory_table(unsigned char **dir_table, u32 **pos_list)
 {
 	u64 start, n_blks, table_offset, table_size;
 	int j, ret = 0, metablks_count = -1, comp_type;
-	struct squashfs_super_block *sblk = ctxt.sblk;
+	struct squashfs_super_block *sblk = sqfs_ctxt.sblk;
 	unsigned char *src_table, *dtb;
 	u32 src_len, dest_offset = 0;
 	unsigned long dest_len;
@@ -730,12 +724,12 @@ static int sqfs_read_directory_table(unsigned char **dir_table, u32 **pos_list)
 	table_size = get_unaligned_le64(&sblk->fragment_table_start) -
 		get_unaligned_le64(&sblk->directory_table_start);
 	start = get_unaligned_le64(&sblk->directory_table_start) /
-		ctxt.cur_dev->blksz;
+		sqfs_ctxt.cur_dev->blksz;
 	n_blks = sqfs_calc_n_blks(sblk->directory_table_start,
 				  sblk->fragment_table_start, &table_offset);
 
 	/* Allocate a proper sized buffer (dtb) to store the directory table */
-	dtb = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
+	dtb = malloc_cache_aligned(n_blks * sqfs_ctxt.cur_dev->blksz);
 	if (!dtb)
 		return -ENOMEM;
 
@@ -891,7 +885,7 @@ free_path:
 
 int sqfs_readdir(struct fs_dir_stream *fs_dirs, struct fs_dirent **dentp)
 {
-	struct squashfs_super_block *sblk = ctxt.sblk;
+	struct squashfs_super_block *sblk = sqfs_ctxt.sblk;
 	struct squashfs_dir_stream *dirs;
 	struct squashfs_lreg_inode *lreg;
 	struct squashfs_base_inode *base;
@@ -1007,8 +1001,8 @@ int sqfs_probe(struct blk_desc *fs_dev_desc, struct disk_partition *fs_partition
 	struct squashfs_super_block *sblk;
 	int ret;
 
-	ctxt.cur_dev = fs_dev_desc;
-	ctxt.cur_part_info = *fs_partition;
+	sqfs_ctxt.cur_dev = fs_dev_desc;
+	sqfs_ctxt.cur_part_info = *fs_partition;
 
 	ret = sqfs_read_sblk(&sblk);
 	if (ret)
@@ -1017,11 +1011,19 @@ int sqfs_probe(struct blk_desc *fs_dev_desc, struct disk_partition *fs_partition
 	/* Make sure it has a valid SquashFS magic number*/
 	if (get_unaligned_le32(&sblk->s_magic) != SQFS_MAGIC_NUMBER) {
 		printf("Bad magic number for SquashFS image.\n");
-		ctxt.cur_dev = NULL;
+		sqfs_ctxt.cur_dev = NULL;
 		return -EINVAL;
 	}
 
-	ctxt.sblk = sblk;
+	sqfs_ctxt.sblk = sblk;
+
+	ret = sqfs_decompressor_init(&sqfs_ctxt);
+
+	if (ret) {
+		sqfs_ctxt.cur_dev = NULL;
+		free(sqfs_ctxt.sblk);
+		return -EINVAL;
+	}
 
 	return 0;
 }
@@ -1196,7 +1198,7 @@ int sqfs_read(const char *filename, void *buf, loff_t offset, loff_t len,
 	char *fragment, *file, *resolved, *data;
 	u64 start, n_blks, table_size, data_offset, table_offset;
 	int ret, j, i_number, comp_type, datablk_count = 0;
-	struct squashfs_super_block *sblk = ctxt.sblk;
+	struct squashfs_super_block *sblk = sqfs_ctxt.sblk;
 	struct squashfs_fragment_block_entry frag_entry;
 	struct squashfs_file_info finfo = {0};
 	struct squashfs_symlink_inode *symlink;
@@ -1315,13 +1317,13 @@ int sqfs_read(const char *filename, void *buf, loff_t offset, loff_t len,
 	}
 
 	for (j = 0; j < datablk_count; j++) {
-		start = data_offset / ctxt.cur_dev->blksz;
+		start = data_offset / sqfs_ctxt.cur_dev->blksz;
 		table_size = SQFS_BLOCK_SIZE(finfo.blk_sizes[j]);
-		table_offset = data_offset - (start * ctxt.cur_dev->blksz);
+		table_offset = data_offset - (start * sqfs_ctxt.cur_dev->blksz);
 		n_blks = DIV_ROUND_UP(table_size + table_offset,
-				      ctxt.cur_dev->blksz);
+				      sqfs_ctxt.cur_dev->blksz);
 
-		data_buffer = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
+		data_buffer = malloc_cache_aligned(n_blks * sqfs_ctxt.cur_dev->blksz);
 
 		if (!data_buffer) {
 			ret = -ENOMEM;
@@ -1369,12 +1371,12 @@ int sqfs_read(const char *filename, void *buf, loff_t offset, loff_t len,
 		goto free_buffer;
 	}
 
-	start = frag_entry.start / ctxt.cur_dev->blksz;
+	start = frag_entry.start / sqfs_ctxt.cur_dev->blksz;
 	table_size = SQFS_BLOCK_SIZE(frag_entry.size);
-	table_offset = frag_entry.start - (start * ctxt.cur_dev->blksz);
-	n_blks = DIV_ROUND_UP(table_size + table_offset, ctxt.cur_dev->blksz);
+	table_offset = frag_entry.start - (start * sqfs_ctxt.cur_dev->blksz);
+	n_blks = DIV_ROUND_UP(table_size + table_offset, sqfs_ctxt.cur_dev->blksz);
 
-	fragment = malloc_cache_aligned(n_blks * ctxt.cur_dev->blksz);
+	fragment = malloc_cache_aligned(n_blks * sqfs_ctxt.cur_dev->blksz);
 
 	if (!fragment) {
 		ret = -ENOMEM;
@@ -1435,7 +1437,7 @@ free_paths:
 
 int sqfs_size(const char *filename, loff_t *size)
 {
-	struct squashfs_super_block *sblk = ctxt.sblk;
+	struct squashfs_super_block *sblk = sqfs_ctxt.sblk;
 	struct squashfs_symlink_inode *symlink;
 	struct fs_dir_stream *dirsp = NULL;
 	struct squashfs_base_inode *base;
@@ -1523,8 +1525,9 @@ free_strings:
 
 void sqfs_close(void)
 {
-	free(ctxt.sblk);
-	ctxt.cur_dev = NULL;
+	free(sqfs_ctxt.sblk);
+	sqfs_ctxt.cur_dev = NULL;
+	sqfs_decompressor_cleanup(&sqfs_ctxt);
 }
 
 void sqfs_closedir(struct fs_dir_stream *dirs)
diff --git a/fs/squashfs/sqfs_decompressor.c b/fs/squashfs/sqfs_decompressor.c
index 09ca6cf6d0..577cffd8bb 100644
--- a/fs/squashfs/sqfs_decompressor.c
+++ b/fs/squashfs/sqfs_decompressor.c
@@ -14,9 +14,39 @@
 #endif
 
 #include "sqfs_decompressor.h"
-#include "sqfs_filesystem.h"
 #include "sqfs_utils.h"
 
+extern struct squashfs_ctxt sqfs_ctxt;
+
+int sqfs_decompressor_init(struct squashfs_ctxt *ctxt)
+{
+	u16 comp_type = get_unaligned_le16(&ctxt->sblk->compression);
+
+	switch (comp_type) {
+#if IS_ENABLED(CONFIG_ZLIB)
+	case SQFS_COMP_ZLIB:
+		break;
+#endif
+	default:
+		printf("Error: unknown compression type.\n");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+void sqfs_decompressor_cleanup(struct squashfs_ctxt *ctxt)
+{
+	u16 comp_type = get_unaligned_le16(&ctxt->sblk->compression);
+
+	switch (comp_type) {
+#if IS_ENABLED(CONFIG_ZLIB)
+	case SQFS_COMP_ZLIB:
+		break;
+#endif
+	}
+}
+
 #if IS_ENABLED(CONFIG_ZLIB)
 static void zlib_decompression_status(int ret)
 {
@@ -35,14 +65,14 @@ static void zlib_decompression_status(int ret)
 #endif
 
 int sqfs_decompress(u16 comp_type, void *dest, unsigned long *dest_len,
-		    void *source, u32 lenp)
+		    void *source, u32 src_len)
 {
 	int ret = 0;
 
 	switch (comp_type) {
 #if IS_ENABLED(CONFIG_ZLIB)
 	case SQFS_COMP_ZLIB:
-		ret = uncompress(dest, dest_len, source, lenp);
+		ret = uncompress(dest, dest_len, source, src_len);
 		if (ret) {
 			zlib_decompression_status(ret);
 			return -EINVAL;
diff --git a/fs/squashfs/sqfs_decompressor.h b/fs/squashfs/sqfs_decompressor.h
index 378965dda8..450257e5ce 100644
--- a/fs/squashfs/sqfs_decompressor.h
+++ b/fs/squashfs/sqfs_decompressor.h
@@ -9,6 +9,7 @@
 #define SQFS_DECOMPRESSOR_H
 
 #include <stdint.h>
+#include "sqfs_filesystem.h"
 
 #define SQFS_COMP_ZLIB 1
 #define SQFS_COMP_LZMA 2
@@ -54,5 +55,7 @@ union squashfs_compression_opts {
 
 int sqfs_decompress(u16 comp_type, void *dest, unsigned long *dest_len,
 		    void *source, u32 lenp);
+int sqfs_decompressor_init(struct squashfs_ctxt *ctxt);
+void sqfs_decompressor_cleanup(struct squashfs_ctxt *ctxt);
 
 #endif /* SQFS_DECOMPRESSOR_H */
diff --git a/fs/squashfs/sqfs_filesystem.h b/fs/squashfs/sqfs_filesystem.h
index d63e3a41ad..ff2b0b1d34 100644
--- a/fs/squashfs/sqfs_filesystem.h
+++ b/fs/squashfs/sqfs_filesystem.h
@@ -9,8 +9,9 @@
 #define SQFS_FILESYSTEM_H
 
 #include <asm/unaligned.h>
-#include <stdint.h>
 #include <fs.h>
+#include <part.h>
+#include <stdint.h>
 
 #define SQFS_UNCOMPRESSED_DATA 0x0002
 #define SQFS_MAGIC_NUMBER 0x73717368
@@ -72,6 +73,12 @@ struct squashfs_super_block {
 	__le64 export_table_start;
 };
 
+struct squashfs_ctxt {
+	struct disk_partition cur_part_info;
+	struct blk_desc *cur_dev;
+	struct squashfs_super_block *sblk;
+};
+
 struct squashfs_directory_index {
 	u32 index;
 	u32 start;
