shinys000114/linux
1
0
Fork 0
mirror of https://github.com/hardkernel/linux.git synced 2026-06-11 05:17:10 +09:00
Code Issues Packages Projects Releases Wiki Activity

fw: update and optimize the fw driver.

Browse Source 
PD#165763:
1. optimized some codes for fw and package parse.
2. adds a feature that the fw which the best match will be loaded.
3. adds the control of the ver for parsing of fw package.

Change-Id: Ia17474df3ff90c6abbe5b617699cfca227f5ea9d
Signed-off-by: Nanxin Qin <nanxin.qin@amlogic.com>
This commit is contained in:
Nanxin Qin
2018-04-18 20:24:41 +08:00
committed by Dongjin Kim
parent 57e7a10398
commit 077fbb3a8f
15 changed files with 629 additions and 498 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
drivers/amlogic/media_modules/common/firmware/firmware_cfg.h
View File

@@ -16,27 +16,17 @@
*/
/*all firmwares in one bin.*/
{MESON_CPU_MAJOR_ID_GXBB, VIDEO_PACKAGE, "video_ucode.bin"},
{MESON_CPU_MAJOR_ID_GXTVBB, VIDEO_PACKAGE, "video_ucode.bin"},
{MESON_CPU_MAJOR_ID_GXL, VIDEO_PACKAGE, "video_ucode.bin"},
{MESON_CPU_MAJOR_ID_GXM, VIDEO_PACKAGE, "video_ucode.bin"},
{MESON_CPU_MAJOR_ID_TXL, VIDEO_PACKAGE, "video_ucode.bin"},
{MESON_CPU_MAJOR_ID_TXLX, VIDEO_PACKAGE, "video_ucode.bin"},
{MESON_CPU_MAJOR_ID_G12A, VIDEO_PACKAGE, "video_ucode.bin"},
{VIDEO_MISC, VIDEO_PACKAGE, "video_ucode.bin"},
/* Note: if the addition of new package has the same name */
/* as the firmware in the video_ucode.bin, the firmware */
/* in the video_ucode.bin will be ignored yet, because the */
/* video_ucode.bin will always be processed in the end */
{MESON_CPU_MAJOR_ID_GXM, VIDEO_PACKAGE, "h264_enc.bin"},
{MESON_CPU_MAJOR_ID_GXL, VIDEO_PACKAGE, "h264_enc.bin"},
{MESON_CPU_MAJOR_ID_TXLX, VIDEO_PACKAGE, "h264_enc.bin"},
{MESON_CPU_MAJOR_ID_TXL, VIDEO_PACKAGE, "h264_enc.bin"},
{MESON_CPU_MAJOR_ID_G12A, VIDEO_PACKAGE, "h264_enc.bin"},
{VIDEO_ENCODE, VIDEO_FW_FILE, "h264_enc.bin"},
/*firmware for a special format, to replace the format in the package.*/
{MESON_CPU_MAJOR_ID_GXL, VIDEO_DEC_HEVC, "h265.bin"},
{MESON_CPU_MAJOR_ID_GXL, VIDEO_DEC_H264, "h264.bin"},
{MESON_CPU_MAJOR_ID_GXL, VIDEO_DEC_H264_MULTI, "h264_multi.bin"},
{VIDEO_DECODE, VIDEO_FW_FILE, "h265.bin"},
{VIDEO_DECODE, VIDEO_FW_FILE, "h264.bin"},
{VIDEO_DECODE, VIDEO_FW_FILE, "h264_multi.bin"},

652
drivers/amlogic/media_modules/common/firmware/firmware_drv.c
View File

File diff suppressed because it is too large Load Diff

50
drivers/amlogic/media_modules/common/firmware/firmware_priv.h
View File

@@ -15,42 +15,52 @@
*
*/
#ifndef __VIDEO_FIRMWARE_PRIV_HEADER_
#define __VIDEO_FIRMWARE_PRIV_HEADER_
#ifndef __VIDEO_FIRMWARE_PRIV_HEAD_
#define __VIDEO_FIRMWARE_PRIV_HEAD_
#include <linux/types.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include "firmware_type.h"
struct firmware_mgr_s {
struct list_head head;
struct fw_mgr_s {
struct list_head fw_head;
struct list_head files_head;
spinlock_t lock;
int cur_cpu;
};
struct firmware_info_s {
struct fw_files_s {
struct list_head node;
int fw_type;
int file_type;
char name[32];
char path[64];
char src_from[32];
enum firmware_type_e type;
struct firmware_s *data;
};
struct ucode_info_s {
int cpu;
enum firmware_type_e type;
struct ucode_file_info_s {
int fw_type;
int file_type;
const char *name;
};
struct firmware_header_s {
struct fw_info_s {
struct list_head node;
char name[32];
char src_from[32];
int file_type;
unsigned int format;
struct firmware_s *data;
};
struct fw_head_s {
int magic;
int checksum;
char name[32];
char cpu[16];
char format[32];
char version[32];
char author[32];
char maker[32];
char date[32];
char commit[16];
int data_size;
@@ -60,28 +70,30 @@ struct firmware_header_s {
struct firmware_s {
union {
struct firmware_header_s header;
struct fw_head_s head;
char buf[512];
};
char data[0];
};
struct package_header_s {
struct package_head_s {
int magic;
int size;
int checksum;
int total;
int version;
char reserved[128];
};
struct package_s {
union {
struct package_header_s header;
struct package_head_s head;
char buf[256];
};
char data[0];
};
struct info_header_s {
struct info_head_s {
char name[32];
char format[32];
char cpu[32];
@@ -90,13 +102,13 @@ struct info_header_s {
struct package_info_s {
union {
struct info_header_s header;
struct info_head_s head;
char buf[256];
};
char data[0];
};
struct firmware_dev_s {
struct fw_dev_s {
struct cdev cdev;
struct device *dev;
dev_t dev_no;

115
drivers/amlogic/media_modules/common/firmware/firmware_type.c
View File

@@ -1,67 +1,92 @@
#include "firmware_type.h"
#include <linux/amlogic/cpu_version.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_MJPEG_MULTI, "mjpeg_multi"},
{VIDEO_DEC_REAL_V8, "real_v8"},
{VIDEO_DEC_REAL_V9, "real_v9"},
{VIDEO_DEC_VC1, "vc1"},
{VIDEO_DEC_VC1_G12A, "vc1_g12a"},
{VIDEO_DEC_AVS, "avs"},
{VIDEO_DEC_AVS_GXM, "avs_gxm"},
{VIDEO_DEC_AVS_NOCABAC, "avs_no_cabac"},
{VIDEO_DEC_H264, "h264"},
{VIDEO_DEC_H264_4k2K, "h264_4k2k"},
{VIDEO_DEC_H264_4k2K_SINGLE, "h264_4k2k_single"},
{VIDEO_DEC_H264_MVC, "h264_mvc"},
{VIDEO_DEC_H264_MVC_GXM, "h264_mvc_gxm"},
{VIDEO_DEC_H264_MULTI, "h264_multi"},
{VIDEO_DEC_H264_MULTI_MMU, "h264_multi_mmu"},
{VIDEO_DEC_H264_MULTI_GXM, "h264_multi_gxm"},
{VIDEO_DEC_HEVC, "hevc"},
{VIDEO_DEC_HEVC_MMU, "hevc_mmu"},
{VIDEO_DEC_HEVC_G12A, "hevc_g12a"},
{VIDEO_DEC_VP9, "vp9"},
{VIDEO_DEC_VP9_MMU, "vp9_mmu"},
{VIDEO_DEC_VP9_G12A, "vp9_g12a"},
{VIDEO_DEC_AVS2, "avs2"},
{VIDEO_DEC_AVS2_MMU, "avs2_mmu"},
{VIDEO_ENC_H264, "h264_enc"},
{VIDEO_ENC_JPEG, "jpeg_enc"},
{FIRMWARE_MAX, "unknown"},
static const struct format_name_s format_name[] = {
{VIDEO_DEC_MPEG12, "mpeg12"},
{VIDEO_DEC_MPEG12_MULTI, "mpeg12_multi"},
{VIDEO_DEC_MPEG4_3, "divx311"},
{VIDEO_DEC_MPEG4_4, "divx4x"},
{VIDEO_DEC_MPEG4_4_MULTI, "divx4x_multi"},
{VIDEO_DEC_MPEG4_5, "xvid"},
{VIDEO_DEC_MPEG4_5_MULTI, "xvid_multi"},
{VIDEO_DEC_H263, "h263"},
{VIDEO_DEC_H263_MULTI, "h263_multi"},
{VIDEO_DEC_MJPEG, "mjpeg"},
{VIDEO_DEC_MJPEG_MULTI, "mjpeg_multi"},
{VIDEO_DEC_REAL_V8, "real_v8"},
{VIDEO_DEC_REAL_V9, "real_v9"},
{VIDEO_DEC_VC1, "vc1"},
{VIDEO_DEC_VC1_G12A, "vc1_g12a"},
{VIDEO_DEC_AVS, "avs"},
{VIDEO_DEC_AVS_GXM, "avs_gxm"},
{VIDEO_DEC_AVS_NOCABAC, "avs_no_cabac"},
{VIDEO_DEC_H264, "h264"},
{VIDEO_DEC_H264_4k2K, "h264_4k2k"},
{VIDEO_DEC_H264_4k2K_SINGLE, "h264_4k2k_single"},
{VIDEO_DEC_H264_MVC, "h264_mvc"},
{VIDEO_DEC_H264_MVC_GXM, "h264_mvc_gxm"},
{VIDEO_DEC_H264_MULTI, "h264_multi"},
{VIDEO_DEC_H264_MULTI_MMU, "h264_multi_mmu"},
{VIDEO_DEC_H264_MULTI_GXM, "h264_multi_gxm"},
{VIDEO_DEC_HEVC, "hevc"},
{VIDEO_DEC_HEVC_MMU, "hevc_mmu"},
{VIDEO_DEC_HEVC_G12A, "hevc_g12a"},
{VIDEO_DEC_VP9, "vp9"},
{VIDEO_DEC_VP9_MMU, "vp9_mmu"},
{VIDEO_DEC_VP9_G12A, "vp9_g12a"},
{VIDEO_DEC_AVS2, "avs2"},
{VIDEO_DEC_AVS2_MMU, "avs2_mmu"},
{VIDEO_ENC_H264, "h264_enc"},
{VIDEO_ENC_JPEG, "jpeg_enc"},
{FIRMWARE_MAX, "unknown"},
};
static const struct cpu_type_s cpu_type[] = {
{MESON_CPU_MAJOR_ID_GXL, "gxl"},
{MESON_CPU_MAJOR_ID_GXM, "gxm"},
{MESON_CPU_MAJOR_ID_G12A, "g12a"},
{MESON_CPU_MAJOR_ID_G12B, "g12b"},
};
const char *get_firmware_type_name(enum firmware_type_e type)
const char *get_fw_format_name(unsigned int format)
{
const char *name = "unknown";
int i, size = ARRAY_SIZE(type_name);
int i, size = ARRAY_SIZE(format_name);
for (i = 0; i < size; i++) {
if (type == type_name[i].type)
name = type_name[i].name;
if (format == format_name[i].format)
name = format_name[i].name;
}
return name;
}
EXPORT_SYMBOL(get_firmware_type_name);
EXPORT_SYMBOL(get_fw_format_name);
enum firmware_type_e get_firmware_type(const char *name)
unsigned int get_fw_format(const char *name)
{
enum firmware_type_e type = FIRMWARE_MAX;
int i, size = ARRAY_SIZE(type_name);
unsigned int format = FIRMWARE_MAX;
int i, size = ARRAY_SIZE(format_name);
for (i = 0; i < size; i++) {
if (!strcmp(name, type_name[i].name))
type = type_name[i].type;
if (!strcmp(name, format_name[i].name))
format = format_name[i].format;
}
return format;
}
EXPORT_SYMBOL(get_fw_format);
int fw_get_cpu(const char *name)
{
int type = 0;
int i, size = ARRAY_SIZE(cpu_type);
for (i = 0; i < size; i++) {
if (!strcmp(name, cpu_type[i].name))
type = cpu_type[i].type;
}
return type;
}
EXPORT_SYMBOL(get_firmware_type);
EXPORT_SYMBOL(fw_get_cpu);

105
drivers/amlogic/media_modules/common/firmware/firmware_type.h
View File

@@ -3,49 +3,74 @@
#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_MJPEG_MULTI,
VIDEO_DEC_REAL_V8,
VIDEO_DEC_REAL_V9,
VIDEO_DEC_VC1,
VIDEO_DEC_AVS,
VIDEO_DEC_H264,
VIDEO_DEC_H264_4k2K,
VIDEO_DEC_H264_4k2K_SINGLE,
VIDEO_DEC_H264_MVC,
VIDEO_DEC_H264_MULTI,
VIDEO_DEC_HEVC,
VIDEO_DEC_HEVC_MMU,
VIDEO_DEC_VP9,
VIDEO_DEC_VP9_MMU,
VIDEO_ENC_H264,
VIDEO_ENC_JPEG,
VIDEO_PACKAGE,
VIDEO_DEC_H264_MULTI_MMU,
VIDEO_DEC_HEVC_G12A,
VIDEO_DEC_VP9_G12A,
VIDEO_DEC_AVS2,
VIDEO_DEC_AVS2_MMU,
VIDEO_DEC_AVS_GXM,
VIDEO_DEC_AVS_NOCABAC,
VIDEO_DEC_H264_MULTI_GXM,
VIDEO_DEC_H264_MVC_GXM,
VIDEO_DEC_VC1_G12A,
FIRMWARE_MAX
};
/* example: #define VIDEO_DEC_AV1 TAG('A', 'V', '1', '-')*/
#define TAG(a, b, c, d)\
((a << 24) | (b << 16) | (c << 8) | d)
struct type_name_s {
enum firmware_type_e type;
/* fws define */
#define VIDEO_DEC_MPEG12 (0)
#define VIDEO_DEC_MPEG4_3 (1)
#define VIDEO_DEC_MPEG4_4 (2)
#define VIDEO_DEC_MPEG4_5 (3)
#define VIDEO_DEC_H263 (4)
#define VIDEO_DEC_MJPEG (5)
#define VIDEO_DEC_MJPEG_MULTI (6)
#define VIDEO_DEC_REAL_V8 (7)
#define VIDEO_DEC_REAL_V9 (8)
#define VIDEO_DEC_VC1 (9)
#define VIDEO_DEC_AVS (10)
#define VIDEO_DEC_H264 (11)
#define VIDEO_DEC_H264_4k2K (12)
#define VIDEO_DEC_H264_4k2K_SINGLE (13)
#define VIDEO_DEC_H264_MVC (14)
#define VIDEO_DEC_H264_MULTI (15)
#define VIDEO_DEC_HEVC (16)
#define VIDEO_DEC_HEVC_MMU (17)
#define VIDEO_DEC_VP9 (18)
#define VIDEO_DEC_VP9_MMU (19)
#define VIDEO_ENC_H264 (20)
#define VIDEO_ENC_JPEG (21)
#define VIDEO_DEC_H264_MULTI_MMU (23)
#define VIDEO_DEC_HEVC_G12A (24)
#define VIDEO_DEC_VP9_G12A (25)
#define VIDEO_DEC_AVS2 (26)
#define VIDEO_DEC_AVS2_MMU (27)
#define VIDEO_DEC_AVS_GXM (28)
#define VIDEO_DEC_AVS_NOCABAC (29)
#define VIDEO_DEC_H264_MULTI_GXM (30)
#define VIDEO_DEC_H264_MVC_GXM (31)
#define VIDEO_DEC_VC1_G12A (32)
#define VIDEO_DEC_MPEG12_MULTI TAG('M', '1', '2', 'M')
#define VIDEO_DEC_MPEG4_4_MULTI TAG('M', '4', '4', 'M')
#define VIDEO_DEC_MPEG4_5_MULTI TAG('M', '4', '5', 'M')
#define VIDEO_DEC_H263_MULTI TAG('2', '6', '3', 'M')
/* ... */
#define FIRMWARE_MAX (UINT_MAX)
#define VIDEO_PACKAGE (0)
#define VIDEO_FW_FILE (1)
#define VIDEO_DECODE (0)
#define VIDEO_ENCODE (1)
#define VIDEO_MISC (2)
#define OPTEE_VDEC_LEGENCY (0)
#define OPTEE_VDEC (1)
#define OPTEE_VDEC_HEVC (2)
struct format_name_s {
unsigned int format;
const char *name;
};
const char *get_firmware_type_name(enum firmware_type_e type);
enum firmware_type_e get_firmware_type(const char *name);
struct cpu_type_s {
int type;
const char *name;
};
const char *get_firmware_type_name(unsigned int format);
unsigned int get_fw_format(const char *name);
int fw_get_cpu(const char *name);
#endif

4
drivers/amlogic/media_modules/frame_provider/decoder/avs/avs.c
View File

@@ -1505,7 +1505,7 @@ static s32 vavs_init(void)
vavs_local_init();
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_GXM)
size = get_firmware_data(VIDEO_DEC_AVS_GXM, buf);
size = get_firmware_data(VIDEO_DEC_AVS, buf);
else {
if (firmware_sel == 1)
size = get_firmware_data(VIDEO_DEC_AVS_NOCABAC, buf);
@@ -1528,7 +1528,7 @@ static s32 vavs_init(void)
pr_info("tee load ok\n");
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_GXM)
size = amvdec_loadmc_ex(VFORMAT_AVS, "avs_gxm", buf);
size = amvdec_loadmc_ex(VFORMAT_AVS, NULL, buf);
else if (firmware_sel == 1)
size = amvdec_loadmc_ex(VFORMAT_AVS, "avs_no_cabac", buf);
else

13
drivers/amlogic/media_modules/frame_provider/decoder/h264/vh264_mvc.c
View File

@@ -1425,12 +1425,7 @@ static s32 vh264mvc_init(void)
if (tee_enabled()) {
pr_info("the video fw from the teeload.\n");
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_GXM)
ret = tee_load_video_fw((u32)VIDEO_DEC_H264_MVC_GXM, 0);
else
ret = tee_load_video_fw((u32)VIDEO_DEC_H264_MVC, 0);
ret = tee_load_video_fw((u32)VIDEO_DEC_H264_MVC, 0);
if (ret != 0) {
amvdec_disable();
return -1;
@@ -1448,11 +1443,7 @@ static s32 vh264mvc_init(void)
WRITE_VREG(UCODE_START_ADDR, mc_dma_handle);
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_GXM)
size = get_firmware_data(VIDEO_DEC_H264_MVC_GXM, buf);
else
size = get_firmware_data(VIDEO_DEC_H264_MVC, buf);
size = get_firmware_data(VIDEO_DEC_H264_MVC, buf);
if (size < 0) {
pr_err("get firmware fail.");
vfree(buf);

13
drivers/amlogic/media_modules/frame_provider/decoder/h264_multi/vmh264.c
View File

@@ -5063,11 +5063,7 @@ static s32 vh264_init(struct vdec_h264_hw_s *hw)
if (IS_ERR_OR_NULL(fw))
return -ENOMEM;
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_GXM)
size = get_firmware_data(VIDEO_DEC_H264_MULTI_GXM, fw->data);
else
size = get_firmware_data(VIDEO_DEC_H264_MULTI, fw->data);
size = get_firmware_data(VIDEO_DEC_H264_MULTI, fw->data);
if (size < 0) {
pr_err("get firmware fail.\n");
vfree(fw);
@@ -6354,12 +6350,7 @@ static void run(struct vdec_s *vdec, unsigned long mask,
start_process_time(hw);
if (tee_enabled()) {
unsigned int fw_type = VIDEO_DEC_H264_MULTI;
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_GXM)
fw_type = VIDEO_DEC_H264_MULTI_GXM;
if (tee_load_video_fw(fw_type, 0) != 0) {
if (tee_load_video_fw(VIDEO_DEC_H264_MULTI, 0) != 0) {
amvdec_enable_flag = false;
amvdec_disable();
pr_err("id: %d, %s: Error amvdec_vdec_loadmc fail\n",

47
drivers/amlogic/media_modules/frame_provider/decoder/h265/vh265.c
View File

@@ -8802,16 +8802,20 @@ static s32 vh265_init(struct hevc_state_s *hevc)
size = 1;
else
#endif
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_G12A) {
size = get_firmware_data(VIDEO_DEC_HEVC_G12A, fw->data);
hevc_print(hevc, 0, "vh265 g12a ucode loaded!\n");
} else if (mmu_enable && (get_cpu_type() >= MESON_CPU_MAJOR_ID_GXL)) {
size = get_firmware_data(VIDEO_DEC_HEVC_MMU, fw->data);
hevc_print(hevc, 0, "vh265 mmu ucode loaded!\n");
if (mmu_enable) {
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_G12A) {
size = get_firmware_data(VIDEO_DEC_HEVC, fw->data);
hevc_print(hevc, 0, "vh265 ucode loaded!\n");
} else {
size = get_firmware_data(VIDEO_DEC_HEVC_MMU, fw->data);
hevc_print(hevc, 0, "vh265 mmu ucode loaded!\n");
}
} else {
size = get_firmware_data(VIDEO_DEC_HEVC, fw->data);
hevc_print(hevc, 0, "vh265 ucode loaded!\n");
}
if (size < 0) {
pr_err("get firmware fail.\n");
vfree(fw);
@@ -8845,12 +8849,13 @@ static s32 vh265_init(struct hevc_state_s *hevc)
if (size == 1) {
pr_info ("tee load ok");
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_G12A)
ret = tee_load_video_fw((u32)VIDEO_DEC_HEVC_G12A, 2);
else if (hevc->mmu_enable &&
(get_cpu_type() >= MESON_CPU_MAJOR_ID_GXL))
ret = tee_load_video_fw((u32)VIDEO_DEC_HEVC_MMU, 0);
else
if (hevc->mmu_enable) {
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_G12A)
ret = tee_load_video_fw((u32)VIDEO_DEC_HEVC, 0);
else
ret = tee_load_video_fw((u32)VIDEO_DEC_HEVC_MMU, 0);
} else
ret = tee_load_video_fw((u32)VIDEO_DEC_HEVC, 0);
} else
ret = amhevc_loadmc_ex(VFORMAT_HEVC, NULL, fw->data);
@@ -9618,7 +9623,7 @@ static void run(struct vdec_s *vdec, unsigned long mask,
{
struct hevc_state_s *hevc =
(struct hevc_state_s *)vdec->private;
int r, loadr;
int r, loadr = 0;
unsigned char check_sum = 0;
run_count[hevc->index]++;
@@ -9682,14 +9687,14 @@ static void run(struct vdec_s *vdec, unsigned long mask,
}
}
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_G12A)
loadr = amhevc_vdec_loadmc_ex(vdec,
"vh265_mc_g12a", hevc->fw->data);
else if (hevc->mmu_enable &&
(get_cpu_type() >= MESON_CPU_MAJOR_ID_GXL))
loadr = amhevc_vdec_loadmc_ex(vdec,
"vh265_mc_mmu", hevc->fw->data);
else
if (hevc->mmu_enable) {
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_G12A)
loadr = amhevc_vdec_loadmc_ex(vdec,
"vh265_mc", hevc->fw->data);
else
loadr = amhevc_vdec_loadmc_ex(vdec,
"vh265_mc_mmu", hevc->fw->data);
} else
loadr = amhevc_vdec_loadmc_ex(vdec,
"vh265_mc", hevc->fw->data);

71
drivers/amlogic/media_modules/frame_provider/decoder/utils/amvdec.c
View File

@@ -375,96 +375,85 @@ static s32 amvdec_loadmc(const u32 *p)
s32 optee_load_fw(enum vformat_e type, const char *fw_name)
{
s32 ret = 0;
s32 ret = -1;
unsigned int format = FIRMWARE_MAX;
unsigned int vdec = OPTEE_VDEC_LEGENCY;
char *name = __getname();
sprintf(name, "%s", fw_name ? fw_name : "null");
switch ((u32)type) {
case VFORMAT_VC1:
ret = tee_load_video_fw((u32)VIDEO_DEC_VC1, 0);
format = VIDEO_DEC_VC1;
break;
case VFORMAT_AVS:
if (!strcmp(name, "avs_gxm"))
ret = tee_load_video_fw((u32)VIDEO_DEC_AVS_GXM, 0);
else if (!strcmp(name, "avs_no_cabac"))
ret = tee_load_video_fw((u32)VIDEO_DEC_AVS_NOCABAC, 0);
if (!strcmp(name, "avs_no_cabac"))
format = VIDEO_DEC_AVS_NOCABAC;
else
ret = tee_load_video_fw((u32)VIDEO_DEC_AVS, 0);
format = VIDEO_DEC_AVS;
break;
case VFORMAT_MPEG12:
ret = tee_load_video_fw((u32)VIDEO_DEC_MPEG12, 0);
format = VIDEO_DEC_MPEG12;
break;
case VFORMAT_MJPEG:
ret = tee_load_video_fw((u32)VIDEO_DEC_MJPEG, 0);
format = VIDEO_DEC_MJPEG;
break;
case VFORMAT_VP9:
if (!strcmp(name, "vp9_mc_g12a"))
ret = tee_load_video_fw((u32)VIDEO_DEC_VP9_G12A, 2);
if (!strcmp(name, "vp9_mc"))
format = VIDEO_DEC_VP9;
else
ret = tee_load_video_fw((u32)VIDEO_DEC_VP9_MMU, 0);
format = VIDEO_DEC_VP9_MMU;
break;
case VFORMAT_AVS2:
ret = tee_load_video_fw((u32)VIDEO_DEC_AVS2_MMU, 2);
format = VIDEO_DEC_AVS2_MMU;
vdec = OPTEE_VDEC_HEVC;
break;
case VFORMAT_HEVC:
if (!strcmp(name, "vh265_mc"))
ret = tee_load_video_fw((u32)VIDEO_DEC_HEVC, 0);
else if (!strcmp(name, "vh265_mc_mmu"))
ret = tee_load_video_fw((u32)VIDEO_DEC_HEVC_MMU, 0);
else if (!strcmp(name, "vh265_mc_g12a"))
ret = tee_load_video_fw((u32)VIDEO_DEC_HEVC_G12A, 2);
format = VIDEO_DEC_HEVC;
else
format = VIDEO_DEC_HEVC_MMU;
break;
case VFORMAT_REAL:
if (!strcmp(name, "vreal_mc_8"))
ret = tee_load_video_fw((u32)VIDEO_DEC_REAL_V8, 0);
format = VIDEO_DEC_REAL_V8;
else if (!strcmp(name, "vreal_mc_9"))
ret = tee_load_video_fw((u32)VIDEO_DEC_REAL_V9, 0);
format = VIDEO_DEC_REAL_V9;
break;
case VFORMAT_MPEG4:
if (!strcmp(name, "vmpeg4_mc_311"))
ret = tee_load_video_fw((u32)VIDEO_DEC_MPEG4_3, 0);
format = VIDEO_DEC_MPEG4_3;
else if (!strcmp(name, "vmpeg4_mc_4"))
ret = tee_load_video_fw((u32)VIDEO_DEC_MPEG4_4, 0);
format = VIDEO_DEC_MPEG4_4;
else if (!strcmp(name, "vmpeg4_mc_5"))
ret = tee_load_video_fw((u32)VIDEO_DEC_MPEG4_5, 0);
format = VIDEO_DEC_MPEG4_5;
else if (!strcmp(name, "h263_mc"))
ret = tee_load_video_fw((u32)VIDEO_DEC_FORMAT_H263, 0);
format = VIDEO_DEC_FORMAT_H263;
break;
default:
if (!strcmp(name, "vh265_mc"))
ret = tee_load_video_fw((u32)VIDEO_DEC_HEVC, 0);
format = VIDEO_DEC_HEVC;
else if (!strcmp(name, "vh265_mc_mmu"))
ret = tee_load_video_fw((u32)VIDEO_DEC_HEVC_MMU, 0);
else if (!strcmp(name, "vmpeg4_mc_311"))
ret = tee_load_video_fw((u32)VIDEO_DEC_MPEG4_3, 0);
else if (!strcmp(name, "vmpeg4_mc_4"))
ret = tee_load_video_fw((u32)VIDEO_DEC_MPEG4_4, 0);
else if (!strcmp(name, "vmpeg4_mc_5"))
ret = tee_load_video_fw((u32)VIDEO_DEC_MPEG4_5, 0);
else if (!strcmp(name, "h263_mc"))
ret = tee_load_video_fw((u32)VIDEO_DEC_FORMAT_H263, 0);
else if (!strcmp(name, "vreal_mc_8"))
ret = tee_load_video_fw((u32)VIDEO_DEC_REAL_V8, 0);
else if (!strcmp(name, "vreal_mc_9"))
ret = tee_load_video_fw((u32)VIDEO_DEC_REAL_V9, 0);
format = VIDEO_DEC_HEVC_MMU;
else if (!strcmp(name, "vmmjpeg_mc"))
ret = tee_load_video_fw((u32)VIDEO_DEC_MJPEG_MULTI, 0);
else if (!strcmp(name, "vh265_mc_g12a"))
ret = tee_load_video_fw((u32)VIDEO_DEC_HEVC_G12A, 2);
format = VIDEO_DEC_MJPEG_MULTI;
else
pr_info("unknow dec format\n");
break;
}
if (format < FIRMWARE_MAX)
ret = tee_load_video_fw(format, vdec);
__putname(name);
return ret;

4
drivers/amlogic/media_modules/frame_provider/decoder/utils/firmware.h
View File

@@ -15,7 +15,7 @@ struct firmware_s {
extern int get_decoder_firmware_data(enum vformat_e type,
const char *file_name, char *buf, int size);
extern int get_data_from_name(const char *name, char *buf);
extern int get_firmware_data(enum firmware_type_e type, char *buf);
extern int firmware_reload(int mode);
extern int get_firmware_data(unsigned int foramt, char *buf);
extern int video_fw_reload(int mode);
#endif

20
drivers/amlogic/media_modules/frame_provider/decoder/vc1/vvc1.c
View File

@@ -1056,20 +1056,12 @@ static s32 vvc1_init(void)
} else
pr_info("not supported VC1 format\n");
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_G12A)
fw_type = VIDEO_DEC_VC1_G12A;
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_G12A && tee_enabled()) {
ret = tee_load_video_fw((u32)fw_type, 1);
size = 1;
} else {
size = get_firmware_data(fw_type, buf);
if (size < 0) {
amvdec_disable();
pr_err("get firmware fail.");
vfree(buf);
return -1;
}
size = get_firmware_data(fw_type, buf);
if (size < 0) {
amvdec_disable();
pr_err("get firmware fail.");
vfree(buf);
return -1;
}
if (size == 1)

9
drivers/amlogic/media_modules/frame_provider/decoder/vp9/vvp9.c
View File

@@ -8057,10 +8057,12 @@ static s32 vvp9_init(struct VP9Decoder_s *pbi)
pr_debug ("laod\n");
} else
#endif
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_G12A)
size = get_firmware_data(VIDEO_DEC_VP9_G12A, fw->data);
size = get_firmware_data(VIDEO_DEC_VP9, fw->data);
else
size = get_firmware_data(VIDEO_DEC_VP9_MMU, fw->data);
if (size < 0) {
pr_err("get firmware fail.\n");
vfree(fw);
@@ -8096,7 +8098,7 @@ static s32 vvp9_init(struct VP9Decoder_s *pbi)
if (size == 1) {
pr_info ("tee load ok\n");
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_G12A)
ret = tee_load_video_fw((u32)VIDEO_DEC_VP9_G12A, 2);
ret = tee_load_video_fw((u32)VIDEO_DEC_VP9, 0);
else
ret = tee_load_video_fw((u32)VIDEO_DEC_VP9_MMU, 0);
} else
@@ -8824,8 +8826,7 @@ static void run_front(struct vdec_s *vdec)
}
if (get_cpu_type() >= MESON_CPU_MAJOR_ID_G12A)
ret = amhevc_loadmc_ex(VFORMAT_VP9,
"vp9_mc_g12a", pbi->fw->data);
ret = amhevc_loadmc_ex(VFORMAT_VP9, "vp9_mc", pbi->fw->data);
else
ret = amhevc_loadmc_ex(VFORMAT_VP9, NULL, pbi->fw->data);

2
drivers/amlogic/media_modules/stream_input/amports/amstream.c
View File

@@ -885,7 +885,7 @@ static int amstream_port_init(struct port_priv_s *priv)
}
/* try to reload the fw.*/
r = firmware_reload(FW_LOAD_TRY);
r = video_fw_reload(FW_LOAD_TRY);
if (r)
pr_err("the firmware reload fail.\n");

BIN
firmware/video/video_ucode.bin
View File

Binary file not shown.