update the firmware drv and optimize some issues.

Change-Id: I823437e16053112f9f177b8727f21be6a316a01e
Signed-off-by: Nanxin Qin <nanxin.qin@amlogic.com>

8 files changed, 293 insertions, 251 deletions

diff --git a/Media.mk b/Media.mk
index 048c31a..4c55f70 100644
--- a/Media.mk
+++ b/Media.mk
@@ -45,6 +45,10 @@ $(error No find the dir of include.)
 endif
 
 MODS_OUT ?= $(MEDIA_DRIVERS)/../modules
+ifeq (,$(wildcard $(MODS_OUT)))
+$(shell mkdir $(MODS_OUT) -p)
+endif
+
 TOOLS := /opt/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu-
 
 modules:
diff --git a/drivers/common/firmware/Makefile b/drivers/common/firmware/Makefile
index d2957a8..748039c 100644
--- a/drivers/common/firmware/Makefile
+++ b/drivers/common/firmware/Makefile
@@ -1 +1,3 @@
 obj-m	+=	firmware.o
+firmware-objs	+=	firmware_drv.o
+firmware-objs	+=	firmware_type.o
diff --git a/drivers/common/firmware/firmware.h b/drivers/common/firmware/firmware.h
index d7d34ea..d1e7c21 100644
--- a/drivers/common/firmware/firmware.h
+++ b/drivers/common/firmware/firmware.h
@@ -20,99 +20,93 @@
 #include <linux/types.h>
 #include <linux/init.h>
 #include <linux/module.h>
-#include <linux/amlogic/media/old_cpu_version.h>
+#include <linux/cdev.h>
+#include "firmware_type.h"
 #include <linux/amlogic/media/utils/vformat.h>
 
-struct video_firmware_s {
 
-	int cpu_type;
+struct firmware_mgr_s {
+	struct list_head head;
+	spinlock_t lock;
+};
 
-	enum vformat_e type;
+struct firmware_info_s {
+	struct list_head node;
+	char name[32];
+	char path[64];
+	enum firmware_type_e type;
+	struct firmware_s *data;
+};
 
+struct ucode_info_s {
+	enum firmware_type_e type;
 	const char *name;
-
-	int size;
-
-	int ref_cnt;
-
-	const char *version;
-
-	struct video_firmware_s *next;
-
-	const char ucode[1];	/*malloced more for ucode. */
 };
-int register_video_firamre_per_cpu(int cputype, enum vformat_e type,
-		const char *name, const char *code, int size, const char *ver);
-int register_video_firamre(int cpus[], enum vformat_e type, const char *name,
-		const char *code, int size, const char *ver);
-int get_decoder_firmware_data(enum vformat_e type, const char *file_name,
-		char *buf, int size);
-
-int show_all_buildin_firmwares(void);
-int get_firmware_data(const char *name, char *buf);
-
-
-#define F_VERSION "0.0.0.0"
-
-#define REGISTER_FIRMARE_PER_CPU_VER(cpu, type, name, ver)\
-		register_video_firamre_per_cpu(cpu, type,\
-		#name, (const char *)name, sizeof(name), ver)
 
-#define REGISTER_FIRMARE_PER_CPU(cpu, type, name)\
-		REGISTER_FIRMARE_PER_CPU_VER(cpu, type, name, F_VERSION)
+struct firmware_header_s {
+	int magic;
+	int checksum;
+	char name[32];
+	char cpu[16];
+	char format[32];
+	char version[32];
+	char author[32];
+	char date[32];
+	char commit[16];
+	int data_size;
+	unsigned int time;
+	char reserved[128];
+};
 
-#define REGISTER_FIRMARE_IN(cpus, type, name, ver)\
-		register_video_firamre(cpus, type,\
-		#name, (const char *)name, sizeof(name), ver)
+struct firmware_s {
+	union {
+		struct firmware_header_s header;
+		char buf[512];
+	};
+	char data[0];
+};
 
-#define DEF_FIRMWARE_FOR_CPUS_TYPE_VER(cpus, type, name, ver)\
-	do {\
-		int t_cpus[] = cpus;\
-		REGISTER_FIRMARE_IN(t_cpus, type, name, ver);\
-	} while (0)
 
-#define DEF_FIRMWARE_FOR_CPUS_TYPE(cpus, type, name)\
-		DEF_FIRMWARE_FOR_CPUS_TYPE_VER(cpus, type, name, F_VERSION)
+struct package_header_s {
+	int magic;
+	int size;
+	int checksum;
+	char reserved[128];
+};
 
-#define DEF_FIRMWARE_FOR_CPUS_VER(cpus, name, ver)\
-		DEF_FIRMWARE_FOR_CPUS_TYPE_VER(cpus, FOR_VFORMAT, name, ver)
+struct package_s {
+	union {
+		struct package_header_s header;
+		char buf[256];
+	};
+	char data[0];
+};
 
-#define DEF_FIRMWARE_FOR_CPUS(cpus, name)\
-		DEF_FIRMWARE_FOR_CPUS_TYPE(cpus, FOR_VFORMAT, name)
+struct info_header_s {
+	char name[32];
+	char format[32];
+	char cpu[32];
+	int length;
+};
 
-#define DEF_FIRMWARE_VER(name, ver)\
-		DEF_FIRMWARE_FOR_CPUS_TYPE_VER(FOR_CPUS, FOR_VFORMAT, name, ver)
+struct package_info_s {
+	union {
+		struct info_header_s header;
+		char buf[256];
+	};
+	char data[0];
+};
 
-#define DEF_FIRMWARE(name)\
-		DEF_FIRMWARE_FOR_CPUS_TYPE_VER(FOR_CPUS, \
-		FOR_VFORMAT, name, F_VERSION)
 
-/*
-*#define INIT_DEF_FIRMWARE()\
-*static int __init init_ucode_per_cpu(void)\
-*	{\
-*		REG_FIRMWARE_ALL();\
-*		return 0;\
-*	}	\
-*module_init(init_ucode_per_cpu);
-*/
+struct firmware_dev_s {
+	struct cdev cdev;
+	struct device *dev;
+	dev_t dev_no;
+};
 
+int get_decoder_firmware_data(enum vformat_e type,
+	const char *file_name, char *buf, int size);
+int get_data_from_name(const char *name, char *buf);
+int get_firmware_data(enum firmware_type_e type, char *buf);
 
-/*
-*sample:
-*
-*#define PER_CPUS {MESON_CPU_MAJOR_ID_M8,MESON_CPU_MAJOR_ID_M8M2,0}
-*#define FOR_VFORMAT VFORMAT_H264
-*
-*#define REG_FIRMWARE_ALL()\
-*		DEF_FIRMWARE(vh264_mc);\
-*		DEF_FIRMWARE(vh264_header_mc);\
-*		DEF_FIRMWARE(vh264_data_mc);\
-*		DEF_FIRMWARE(vh264_mmco_mc);\
-*		DEF_FIRMWARE(vh264_list_mc);\
-*		DEF_FIRMWARE(vh264_slice_mc);\
-*		DEF_FIRMWARE_VER(vh264_slice_mc,"1.0");\
-*
-*INIT_DEF_FIRMWARE();
-*/
 #endif
diff --git a/drivers/common/firmware/firmware_info.h b/drivers/common/firmware/firmware_cfg.h
index 3d2cdd9..577460e 100644
--- a/drivers/common/firmware/firmware_info.h
+++ b/drivers/common/firmware/firmware_cfg.h
@@ -15,9 +15,9 @@
  *
 */
 
-{MESON_CPU_MAJOR_ID_GXL, "gxl_vh265.bin"},
+{VIDEO_PACKAGE, "gxl_ucode.bin"},
 
-{MESON_CPU_MAJOR_ID_GXL, "gxl_ucode.bin"},
+{VIDEO_DEC_HEVC, "gxl_h265.bin"},
 
-{MESON_CPU_MAJOR_ID_GXL, "gxl_h264_all.bin"},
+{VIDEO_DEC_H264, "gxl_h264.bin"},
 
diff --git a/drivers/common/firmware/firmware.c b/drivers/common/firmware/firmware_drv.c
index fc31c22..f86ad8d 100644
--- a/drivers/common/firmware/firmware.c
+++ b/drivers/common/firmware/firmware_drv.c
@@ -32,7 +32,7 @@
 #include "../../frame_provider/decoder/utils/vdec.h"
 #include "firmware.h"
 #include "../chips/chips.h"
-#include "linux/string.h"
+#include <linux/string.h>
 #include <linux/amlogic/media/utils/log.h>
 #include <linux/firmware.h>
 #include <linux/amlogic/major.h>
@@ -51,91 +51,79 @@
 
 static DEFINE_MUTEX(mutex);
 
-struct firmware_mgr_s {
-	struct list_head head;
-	spinlock_t lock;
+static  struct ucode_info_s ucode_info[] = {
+#include "firmware_cfg.h"
 };
 
-struct firmware_info_s {
-	struct list_head node;
-	char path[64];
-	char firmware_name[32];
-	struct firmware_s *data;
+static const struct file_operations firmware_fops = {
+	.owner = THIS_MODULE
 };
 
-struct ucode_info_s {
-	int cpu_version;
-	const char *name;
-};
+struct firmware_mgr_s *g_mgr;
+struct firmware_dev_s *g_dev;
 
-struct firmware_header_s {
-	int magic;
-	int checksum;
-	char version[32];
-	char author[32];
-	char date[32];
-	char commit[16];
-	int data_size;
-	unsigned int time;
-	char reserved[32];
-};
+static u32 debug = 0;
 
-struct firmware_s {
-	union {
-		struct firmware_header_s header;
-		char buf[256];
-	};
-	char data[0];
-};
+int get_firmware_data(enum firmware_type_e type, char *buf)
+{
+	int data_len, ret = -1;
+	struct firmware_mgr_s *mgr = g_mgr;
+	struct firmware_info_s *info;
 
-struct package_header_s {
-	int magic;
-	int size;
-	int checksum;
-	char reserved[128];
-};
+	if (list_empty(&mgr->head)) {
+		pr_info("the info list is empty.\n");
+		return 0;
+	}
 
-struct package_s {
-	union {
-		struct package_header_s header;
-		char buf[256];
-	};
-	char data[0];
-};
+	list_for_each_entry(info, &mgr->head, node) {
+		if (type != info->type)
+			continue;
 
-struct info_header_s {
-	char name[32];
-	char format[32];
-	char cpu[32];
-	int length;
-};
+		data_len = info->data->header.data_size;
+		memcpy(buf, info->data->data, data_len);
+		ret = data_len;
 
-struct package_info_s {
-	union {
-		struct info_header_s header;
-		char buf[256];
-	};
-	char data[0];
-};
+		break;
+	}
 
-static  struct ucode_info_s ucode_info[] = {
-#include "firmware_info.h"
-};
+	return ret;
+}
+EXPORT_SYMBOL(get_firmware_data);
 
-struct firmware_dev_s {
-	struct cdev cdev;
-	struct device *dev;
-	dev_t dev_no;
-};
+int get_data_from_name(const char *name, char *buf)
+{
+	int data_len, ret = -1;
+	struct firmware_mgr_s *mgr = g_mgr;
+	struct firmware_info_s *info;
+	char *firmware_name = __getname();
 
-static const struct file_operations firmware_fops = {
-	.owner = THIS_MODULE
-};
+	if (IS_ERR_OR_NULL(firmware_name))
+		return -ENOMEM;
 
-struct firmware_mgr_s *g_mgr;
-struct firmware_dev_s *g_dev;
+	strcat(firmware_name, name);
+	strcat(firmware_name, ".bin");
 
-static u32 debug = 0;
+	if (list_empty(&mgr->head)) {
+		pr_info("the info list is empty.\n");
+		return 0;
+	}
+
+	list_for_each_entry(info, &mgr->head, node) {
+		if (strcmp(firmware_name, info->name))
+			continue;
+
+		data_len = info->data->header.data_size;
+		memcpy(buf, info->data->data, data_len);
+		ret = data_len;
+
+		break;
+	}
+
+	__putname(firmware_name);
+
+	return ret;
+}
+EXPORT_SYMBOL(get_data_from_name);
 
 static int request_firmware_from_sys(const char *file_name,
 		char *buf, int size)
@@ -173,7 +161,7 @@ int request_decoder_firmware_on_sys(enum vformat_e type,
 {
 	int ret;
 
-	ret = get_firmware_data(file_name, buf);
+	ret = get_data_from_name(file_name, buf);
 	if (ret < 0)
 		pr_info("Get firmware fail.\n");
 
@@ -247,13 +235,19 @@ static void walk_firmware_info(void)
 			continue;
 
 		pr_info("path : %s.\n", info->path);
-		pr_info("name : %s.\n", info->firmware_name);
-		pr_info("version : %s.\n", info->data->header.version);
-		pr_info("checksum : 0x%x.\n", info->data->header.checksum);
-		pr_info("data size : %d.\n", info->data->header.data_size);
-		pr_info("author : %s.\n", info->data->header.author);
-		pr_info("date : %s.\n", info->data->header.date);
-		pr_info("commit : %s.\n\n", info->data->header.commit);
+		pr_info("name : %s.\n", info->name);
+		pr_info("version : %s.\n",
+			info->data->header.version);
+		pr_info("checksum : 0x%x.\n",
+			info->data->header.checksum);
+		pr_info("data size : %d.\n",
+			info->data->header.data_size);
+		pr_info("author : %s.\n",
+			info->data->header.author);
+		pr_info("date : %s.\n",
+			info->data->header.date);
+		pr_info("commit : %s.\n\n",
+			info->data->header.commit);
 	}
 }
 
@@ -273,20 +267,19 @@ static ssize_t info_show(struct class *class,
 		if (IS_ERR_OR_NULL(info->data))
 			continue;
 
-		pr_info( "%10s : %s\n", "name",
-				info->firmware_name);
+		pr_info( "%10s : %s\n", "name", info->name);
 		pr_info( "%10s : %d\n", "size",
-				info->data->header.data_size);
-		pr_info( "%10s : %s\n", "version",
-				info->data->header.version);
-		pr_info( "%10s : 0x%x\n", "checksum",
-				info->data->header.checksum);
+			info->data->header.data_size);
+		pr_info( "%10s : %s\n", "ver",
+			info->data->header.version);
+		pr_info( "%10s : 0x%x\n", "sum",
+			info->data->header.checksum);
 		pr_info( "%10s : %s\n", "commit",
-				info->data->header.commit);
+			info->data->header.commit);
 		pr_info( "%10s : %s\n", "author",
-				info->data->header.author);
+			info->data->header.author);
 		pr_info( "%10s : %s\n\n", "date",
-				info->data->header.date);
+			info->data->header.date);
 	}
 out:
 	return pbuf - buf;
@@ -297,17 +290,13 @@ static int set_firmware_info(void)
 	int ret = 0, i, len;
 	struct firmware_info_s *info;
 	int info_size = ARRAY_SIZE(ucode_info);
-	int cpu_version = get_cpu_type();
-	const char *name;
 	char *path = __getname();
+	const char *name;
 
 	if (IS_ERR_OR_NULL(path))
 		return -ENOMEM;
 
 	for (i = 0; i < info_size; i++) {
-		if (cpu_version != ucode_info[i].cpu_version)
-			continue;
-
 		name = ucode_info[i].name;
 		if (IS_ERR_OR_NULL(name))
 			break;
@@ -324,7 +313,8 @@ static int set_firmware_info(void)
 		}
 
 		strcpy(info->path, path);
-		strcpy(info->firmware_name, name);
+		strcpy(info->name, name);
+		info->type = ucode_info[i].type;
 		info->data = NULL;
 
 		add_info(info);
@@ -368,24 +358,24 @@ static int check_repeat(struct firmware_s *data, const char *name)
 	list_for_each_entry(info, &mgr->head, node) {
 		struct firmware_s *tmp;
 
-		if (strcmp(info->firmware_name, name))
+		if (strcmp(info->name, name))
 			continue;
 
 		if (IS_ERR_OR_NULL(info->data)) {
-			pr_info("the data is null.\n");
+			pr_info("the %s data is null.\n", info->name);
 			info->data = data;
 
 			return 1;
 		}
 
 		if (info->data->header.time >= data->header.time) {
-			pr_info("the data is old.\n");
+			pr_info("the %s data is old.\n", info->name);
 			kfree(data);
 
 			return 1;
 		}
 
-		pr_info("the data is new.\n");
+		pr_info("the %s data is new.\n", info->name);
 		tmp = info->data;
 		info->data = data;
 		kfree(tmp);
@@ -396,7 +386,8 @@ static int check_repeat(struct firmware_s *data, const char *name)
 	return 0;
 }
 
-static int firmware_parse_package(char *buf, int size)
+static int firmware_parse_package(struct firmware_info_s *package,
+	char *buf, int size)
 {
 	int ret = 0;
 	struct package_s *pack;
@@ -408,13 +399,16 @@ static int firmware_parse_package(char *buf, int size)
 	int info_len, len;
 	char *path = __getname();
 
-	if (IS_ERR_OR_NULL(path))
-		return -ENOMEM;
+	if (IS_ERR_OR_NULL(path)) {
+		ret = -ENOMEM;
+		goto err;
+	}
 
 	pack = vmalloc(PACK_SIZE);
 	if (IS_ERR_OR_NULL(pack)) {
 		__putname(path);
-		return -ENOMEM;
+		ret = -ENOMEM;
+		goto err;
 	}
 
 	memset(pack, 0, PACK_SIZE);
@@ -451,7 +445,8 @@ static int firmware_parse_package(char *buf, int size)
 		}
 
 		strcpy(info->path, path);
-		strcpy(info->firmware_name, pack_info->header.name);
+		strcpy(info->name, pack_info->header.name);
+		info->type = get_firmware_type(pack_info->header.format);
 
 		len = pack_info->header.length;
 		memcpy(data, pack_info->data, len);
@@ -466,7 +461,7 @@ static int firmware_parse_package(char *buf, int size)
 			goto out;
 		}
 
-		if (check_repeat(data, info->firmware_name)) {
+		if (check_repeat(data, info->name)) {
 			kfree(info);
 			continue;
 		}
@@ -477,6 +472,8 @@ static int firmware_parse_package(char *buf, int size)
 out:
 	__putname(path);
 	vfree(pack);
+err:
+	del_info(package);
 
 	return ret;
 }
@@ -484,6 +481,15 @@ out:
 static int firmware_parse_code(struct firmware_info_s *info,
 	char *buf, int size)
 {
+	const char *cpu = get_cpu_type_name();
+	struct firmware_s *data;
+
+	data = (struct firmware_s *)buf;
+	if (strcmp(cpu, data->header.cpu)) {
+		del_info(info);
+		return 0;
+	}
+
 	info->data = kzalloc(FRIMWARE_SIZE, GFP_KERNEL);
 	if (IS_ERR_OR_NULL(info->data))
 		return -ENOMEM;
@@ -513,7 +519,7 @@ static int get_firmware_from_sys(const char *path,
 
 static int set_firmware_data(void)
 {
-	int magic = 0;
+	int ret = 0, magic = 0;
 	struct firmware_mgr_s *mgr = g_mgr;
 	struct firmware_info_s *info, *temp;
 	char *buf;
@@ -534,12 +540,11 @@ static int set_firmware_data(void)
 
 		switch (magic) {
 		case PACK:
-			firmware_parse_package(buf, size);
-			del_info(info);
+			ret = firmware_parse_package(info, buf, size);
 			break;
 
 		case CODE:
-			firmware_parse_code(info, buf, size);
+			ret = firmware_parse_code(info, buf, size);
 			break;
 
 		default:
@@ -555,43 +560,8 @@ static int set_firmware_data(void)
 
 	vfree(buf);
 
-	return 0;
-}
-
-int get_firmware_data(const char *name, char *buf)
-{
-	int data_len, ret = -1;
-	struct firmware_mgr_s *mgr = g_mgr;
-	struct firmware_info_s *info;
-	char *firmware_name = __getname();
-
-	if (IS_ERR_OR_NULL(firmware_name))
-		return -ENOMEM;
-
-	strcat(firmware_name, name);
-	strcat(firmware_name, ".bin");
-
-	if (list_empty(&mgr->head)) {
-		pr_info("the info list is empty.\n");
-		return 0;
-	}
-
-	list_for_each_entry(info, &mgr->head, node) {
-		if (strcmp(firmware_name, info->firmware_name))
-			continue;
-
-		data_len = info->data->header.data_size;
-		memcpy(buf, info->data->data, data_len);
-		ret = data_len;
-
-		break;
-	}
-
-	__putname(firmware_name);
-
 	return ret;
 }
-EXPORT_SYMBOL(get_firmware_data);
 
 static int firmware_pre_load(void)
 {
diff --git a/drivers/common/firmware/firmware_type.c b/drivers/common/firmware/firmware_type.c
new file mode 100644
index 0000000..033e7c1
--- a/dev/null
+++ b/drivers/common/firmware/firmware_type.c
@@ -0,0 +1,50 @@
+#include "firmware_type.h"
+
+static const struct type_name_s type_name[] = {
+	{VIDEO_DEC_MPEG12, "mpeg12"},
+	{VIDEO_DEC_MPEG4_3, "divx311"},
+	{VIDEO_DEC_MPEG4_4, "divx4x"},
+	{VIDEO_DEC_MPEG4_5, "xvid"},
+	{VIDEO_DEC_H263, "h263"},
+	{VIDEO_DEC_MJPEG, "mjpeg"},
+	{VIDEO_DEC_REAL, "real"},
+	{VIDEO_DEC_VC1, "vc1"},
+	{VIDEO_DEC_AVS, "avs"},
+	{VIDEO_DEC_H264, "h264"},
+	{VIDEO_DEC_H264_MULTI, "h264_multi"},
+	{VIDEO_DEC_HEVC, "hevc"},
+	{VIDEO_DEC_VP9, "vp9"},
+	{VIDEO_ENC_H264, "h264_enc"},
+	{VIDEO_ENC_JPEG, "jpeg_enc"},
+	{FIRMWARE_MAX, "unknown"},
+};
+
+
+const char *get_firmware_type_name(enum firmware_type_e type)
+{
+	const char *name = "unknown";
+	int i, size = ARRAY_SIZE(type_name);
+
+	for (i = 0; i < size; i++) {
+		if (type == type_name[i].type)
+			name = type_name[i].name;
+	}
+
+	return name;
+}
+EXPORT_SYMBOL(get_firmware_type_name);
+
+enum firmware_type_e get_firmware_type(const char *name)
+{
+	enum firmware_type_e type = FIRMWARE_MAX;
+	int i, size = ARRAY_SIZE(type_name);
+
+	for (i = 0; i < size; i++) {
+		if (!strcmp(name, type_name[i].name))
+			type = type_name[i].type;
+	}
+
+	return type;
+}
+EXPORT_SYMBOL(get_firmware_type);
+
diff --git a/drivers/common/firmware/firmware_type.h b/drivers/common/firmware/firmware_type.h
new file mode 100644
index 0000000..b5cd58f
--- a/dev/null
+++ b/drivers/common/firmware/firmware_type.h
@@ -0,0 +1,34 @@
+#ifndef __VIDEO_FIRMWARE_FORMAT_
+#define __VIDEO_FIRMWARE_FORMAT_
+
+#include <linux/slab.h>
+
+enum firmware_type_e {
+	VIDEO_DEC_MPEG12,
+	VIDEO_DEC_MPEG4_3,
+	VIDEO_DEC_MPEG4_4,
+	VIDEO_DEC_MPEG4_5,
+	VIDEO_DEC_H263,
+	VIDEO_DEC_MJPEG,
+	VIDEO_DEC_REAL,
+	VIDEO_DEC_VC1,
+	VIDEO_DEC_AVS,
+	VIDEO_DEC_H264,
+	VIDEO_DEC_H264_MULTI,
+	VIDEO_DEC_HEVC,
+	VIDEO_DEC_VP9,
+	VIDEO_ENC_H264,
+	VIDEO_ENC_JPEG,
+	VIDEO_PACKAGE,
+	FIRMWARE_MAX
+};
+
+struct type_name_s {
+	enum firmware_type_e type;
+	const char *name;
+};
+
+const char *get_firmware_type_name(enum firmware_type_e type);
+enum firmware_type_e get_firmware_type(const char *name);
+
+#endif
diff --git a/drivers/frame_provider/decoder/h264/vh264.c b/drivers/frame_provider/decoder/h264/vh264.c
index 08bb598..9d554a0 100644
--- a/drivers/frame_provider/decoder/h264/vh264.c
+++ b/drivers/frame_provider/decoder/h264/vh264.c
@@ -2367,39 +2367,27 @@ static s32 vh264_init(void)
 		firmwareloaded = 1;
 	} else {
 		int ret = -1, size = -1;
-		unsigned int cpu = get_cpu_type();
 		char *buf = vmalloc(0x1000 * 8);
 
-		switch (cpu) {
-		case MESON_CPU_MAJOR_ID_GXTVBB:
-		case MESON_CPU_MAJOR_ID_GXL:
-			size = get_firmware_data("gxl_h264_all", buf);
-			if (size < 0) {
-				pr_err("get firmware fail.");
-				vfree(buf);
-				return -1;
-			}
-
-			ret = amvdec_loadmc_ex(VFORMAT_H264,
-				"gxl_h264_all", buf);
-			memcpy((u8 *) mc_cpu_addr + MC_OFFSET_HEADER,
-				buf + 0x4000, MC_SWAP_SIZE);
-			memcpy((u8 *) mc_cpu_addr + MC_OFFSET_DATA,
-				buf + 0x2000, MC_SWAP_SIZE);
-			memcpy((u8 *) mc_cpu_addr + MC_OFFSET_MMCO,
-				buf + 0x6000, MC_SWAP_SIZE);
-			memcpy((u8 *) mc_cpu_addr + MC_OFFSET_LIST,
-				buf + 0x3000, MC_SWAP_SIZE);
-			memcpy((u8 *) mc_cpu_addr + MC_OFFSET_SLICE,
-				buf + 0x5000, MC_SWAP_SIZE);
-			break;
-
-		default:
-			pr_err("invalid cpu type 0x%x.\n", cpu);
+		size = get_firmware_data(VIDEO_DEC_H264, buf);
+		if (size < 0) {
+			pr_err("get firmware fail.");
 			vfree(buf);
 			return -1;
 		}
 
+		ret = amvdec_loadmc_ex(VFORMAT_H264, NULL, buf);
+		memcpy((u8 *) mc_cpu_addr + MC_OFFSET_HEADER,
+			buf + 0x4000, MC_SWAP_SIZE);
+		memcpy((u8 *) mc_cpu_addr + MC_OFFSET_DATA,
+			buf + 0x2000, MC_SWAP_SIZE);
+		memcpy((u8 *) mc_cpu_addr + MC_OFFSET_MMCO,
+			buf + 0x6000, MC_SWAP_SIZE);
+		memcpy((u8 *) mc_cpu_addr + MC_OFFSET_LIST,
+			buf + 0x3000, MC_SWAP_SIZE);
+		memcpy((u8 *) mc_cpu_addr + MC_OFFSET_SLICE,
+			buf + 0x5000, MC_SWAP_SIZE);
+
 		vfree(buf);
 
 		if (ret < 0) {