/*
* INTEL CONFIDENTIAL
* Copyright 2007 Intel Corporation. All Rights Reserved.
* Copyright 2005-2007 Imagination Technologies Limited. All Rights Reserved.
*
* The source code contained or described herein and all documents related to
* the source code ("Material") are owned by Intel Corporation or its suppliers
* or licensors. Title to the Material remains with Intel Corporation or its
* suppliers and licensors. The Material may contain trade secrets and
* proprietary and confidential information of Intel Corporation and its
* suppliers and licensors, and is protected by worldwide copyright and trade
* secret laws and treaty provisions. No part of the Material may be used,
* copied, reproduced, modified, published, uploaded, posted, transmitted,
* distributed, or disclosed in any way without Intel's prior express written
* permission.
*
* No license under any patent, copyright, trade secret or other intellectual
* property right is granted to or conferred upon you by disclosure or delivery
* of the Materials, either expressly, by implication, inducement, estoppel or
* otherwise. Any license under such intellectual property rights must be
* express and approved by Intel in writing.
*/
/*
* Authors:
* Elaine Wang <zhaohan.ren@intel.com>
*
*/
#include <stdio.h>
#include "JPEGMasterFirmware_bin.h"
#include "H264MasterFirmware_bin.h"
#include "H264MasterFirmwareCBR_bin.h"
#include "H264MasterFirmwareVBR_bin.h"
#include "H264MasterFirmwareVCM_bin.h"
#include "H264MasterFirmwareLLRC_bin.h"
#include "H264MasterFirmwareALL_bin.h"
#include "H263MasterFirmware_bin.h"
#include "H263MasterFirmwareCBR_bin.h"
#include "H263MasterFirmwareVBR_bin.h"
//#include "H263MasterFirmwareLLRC_bin.h"
#include "MPG2MasterFirmware_bin.h"
#include "MPG2MasterFirmwareCBR_bin.h"
#include "MPG2MasterFirmwareVBR_bin.h"
//#include "MPG2MasterFirmwareLLRC_bin.h"
#include "MPG4MasterFirmware_bin.h"
#include "MPG4MasterFirmwareCBR_bin.h"
#include "MPG4MasterFirmwareVBR_bin.h"
#include "MPG4MasterFirmwareLLRC_bin.h"
#include "H264MVCMasterFirmware_bin.h"
#include "H264MVCMasterFirmwareCBR_bin.h"
#include "H264MVCMasterFirmwareVBR_bin.h"
#include "H264MVCMasterFirmwareLLRC_bin.h"
#include "thread0_bin.h"
#include "Primary_VRL.txt"
#define FW_VER 0x5D
#define FW_FILE_NAME_A0 "topazhp_fw.bin"
#define FW_FILE_NAME_B0 "topazhp_fw_b0.bin"
static const unsigned char pad_val = 0x0;
#define FW_MASTER_INFO(codec,prefix) \
{ FW_MASTER_##codec,\
{ FW_VER,\
FW_MASTER_##codec,\
ui32##prefix##_MasterMTXTOPAZFWTextSize,\
ui32##prefix##_MasterMTXTOPAZFWDataSize,\
ui32##prefix##_MasterMTXTOPAZFWDataOrigin\
},\
aui32##prefix##_MasterMTXTOPAZFWText, aui32##prefix##_MasterMTXTOPAZFWData \
}
#define FW_SLAVE_INFO(codec,prefix) \
{ FW_SLAVE_##codec,\
{ FW_VER,\
FW_SLAVE_##codec,\
ui32##prefix##_SlaveMTXTOPAZFWTextSize,\
ui32##prefix##_SlaveMTXTOPAZFWDataSize,\
ui32##prefix##_SlaveMTXTOPAZFWDataOrigin\
},\
aui32##prefix##_SlaveMTXTOPAZFWText, aui32##prefix##_SlaveMTXTOPAZFWData \
}
struct topaz_fw_info_item_s {
unsigned short ver;
unsigned short codec;
unsigned int text_size;
unsigned int data_size;
unsigned int data_location;
};
typedef struct topaz_fw_info_item_s topaz_fw_info_item_t;
/* Commented out all the SLAVE structure according to DDK */
enum topaz_fw_codec_e {
FW_MASTER_JPEG = 0, //!< JPEG
FW_MASTER_H264_NO_RC, //!< H264 with no rate control
FW_MASTER_H264_VBR, //!< H264 variable bitrate
FW_MASTER_H264_CBR, //!< H264 constant bitrate
FW_MASTER_H264_VCM, //!< H264 video conferance mode
FW_MASTER_H264_LLRC, //!< H264 low-latency rate control
FW_MASTER_H264ALL,
FW_MASTER_H263_NO_RC, //!< H263 with no rate control
FW_MASTER_H263_VBR, //!< H263 variable bitrate
FW_MASTER_H263_CBR, //!< H263 constant bitrate
FW_MASTER_MPEG4_NO_RC, //!< MPEG4 with no rate control
FW_MASTER_MPEG4_VBR, //!< MPEG4 variable bitrate
FW_MASTER_MPEG4_CBR, //!< MPEG4 constant bitrate
FW_MASTER_MPEG2_NO_RC, //!< MPEG2 with no rate control
FW_MASTER_MPEG2_VBR, //!< MPEG2 variable bitrate
FW_MASTER_MPEG2_CBR, //!< MPEG2 constant bitrate
FW_MASTER_H264MVC_NO_RC, //!< MVC H264 with no rate control
FW_MASTER_H264MVC_CBR, //!< MVC H264 constant bitrate
FW_MASTER_H264MVC_VBR, //!< MVC H264 variable bitrate
FW_MASTER_H264MVC_LLRC, //!< MVC H264 low-latency rate control
FW_NUM
};
typedef enum topaz_fw_codec_e topaz_fw_codec_t;
struct fw_table_s {
topaz_fw_codec_t index;
topaz_fw_info_item_t header;
unsigned int *fw_text;
unsigned int *fw_data;
};
typedef struct fw_table_s fw_table_t;
#define SECURE_ALIGN 1
#define B0_ALIGN 4
#define SECURE_VRL_HEADER 728
#define SECURE_FIP_HEADER 296
struct fw_table_A0 {
unsigned int addr;
unsigned int text_size_bytes;
unsigned int data_size_bytes;
unsigned int data_relocation;
};
static void create_firmware_A0(fw_table_t *tng_fw_table, FILE *fp)
{
struct fw_table_A0 sec_t[FW_NUM];
const unsigned int ui_secure_align = SECURE_ALIGN - 1;
unsigned int i = 0;
int iter = 0;
int size = 0;
printf("fm num is %d\n", FW_NUM);
/////////////////////////////////////////////////
size = SECURE_VRL_HEADER + SECURE_FIP_HEADER;
for (iter = 0; iter < size; iter++) {
fwrite(&pad_val, 1, 1, fp);
}
/////////////////////////////////////////////////
iter = 0;
sec_t[iter].addr = FW_NUM * 16 + SECURE_VRL_HEADER + SECURE_FIP_HEADER;
sec_t[iter].text_size_bytes = tng_fw_table[iter].header.text_size * 4;
sec_t[iter].data_size_bytes = tng_fw_table[iter].header.data_size * 4;
sec_t[iter].data_relocation = tng_fw_table[iter].header.data_location;
fwrite(&(sec_t[iter]), sizeof(struct fw_table_A0), 1, fp);
iter = 1;
/* write fw table into the file */
while (iter < FW_NUM) {
sec_t[iter - 1].text_size_bytes = (sec_t[iter - 1].text_size_bytes + ui_secure_align) & (~ui_secure_align);
sec_t[iter - 1].data_size_bytes = (sec_t[iter - 1].data_size_bytes + ui_secure_align) & (~ui_secure_align);
sec_t[iter].addr = sec_t[iter-1].addr + sec_t[iter-1].text_size_bytes + sec_t[iter-1].data_size_bytes;
sec_t[iter].text_size_bytes = tng_fw_table[iter].header.text_size * 4;
sec_t[iter].data_size_bytes = tng_fw_table[iter].header.data_size * 4;
sec_t[iter].data_relocation = tng_fw_table[iter].header.data_location;
fwrite(&(sec_t[iter]), sizeof(struct fw_table_A0), 1, fp);
++iter;
}
sec_t[iter - 1].text_size_bytes = (sec_t[iter - 1].text_size_bytes + ui_secure_align) & (~ui_secure_align);
sec_t[iter - 1].data_size_bytes = (sec_t[iter - 1].data_size_bytes + ui_secure_align) & (~ui_secure_align);
iter = 0;
while (iter < FW_NUM) {
/* write text */
size = tng_fw_table[iter].header.text_size * 4;
fwrite(tng_fw_table[iter].fw_text, 1, size, fp);
for (i = 0; i < (sec_t[iter].text_size_bytes - size); i++)
fwrite(&pad_val, 1, 1, fp);
/* write data */
size = tng_fw_table[iter].header.data_size * 4;
fwrite(tng_fw_table[iter].fw_data, 1, size, fp);
for (i = 0; i < (sec_t[iter].data_size_bytes - size); i++)
fwrite(&pad_val, 1, 1, fp);
fflush(fp);
++iter;
}
return ;
}
struct fw_table_B0 {
unsigned int addr;
unsigned int text_size_dword;
unsigned int data_size_dword;
unsigned int text_size_bytes;
};
static const char FIP_Header[] = {
0x24, 0x56, 0x45, 0x43,
0x01, 0x00, 0x01, 0x00,
0x4a, 0x00, 0x00, 0x00,
0x8e, 0x00, 0x00, 0x00,
0x22, 0x00, 0x9c, 0x00,
0x0e, 0x00, 0x00, 0x00
};
static void create_firmware_B0(fw_table_t *tng_fw_table, FILE *fp)
{
struct fw_table_B0 sec_t[FW_NUM];
const unsigned int i_align = B0_ALIGN - 1;
const unsigned int data_loco = 0x0ffff;
unsigned int i = 0;
int iter = 0;
int size = 0;
printf("fm num is %d\n", FW_NUM);
/////////////////////////////////////////////////
size = sizeof(FIP_Header);
fwrite(FIP_Header, size, 1, fp);
printf("FIP header is %d, 296\n", size);
size = SECURE_FIP_HEADER - sizeof(FIP_Header);
for (iter = 0; iter < size; iter++) {
fwrite(&pad_val, 1, 1, fp);
}
/////////////////////////////////////////////////
iter = 0;
sec_t[iter].addr = FW_NUM * 16 + SECURE_VRL_HEADER + SECURE_FIP_HEADER;
sec_t[iter].text_size_bytes = tng_fw_table[iter].header.data_location & data_loco;
sec_t[iter].text_size_dword = sec_t[iter].text_size_bytes >> 2;
sec_t[iter].data_size_dword = (tng_fw_table[iter].header.data_size + i_align) & (~i_align);
fwrite(&(sec_t[iter]), sizeof(struct fw_table_B0), 1, fp);
iter = 1;
/* write fw table into the file */
while (iter < FW_NUM) {
sec_t[iter].addr = sec_t[iter-1].addr +
sec_t[iter-1].text_size_bytes +
(sec_t[iter-1].data_size_dword << 2);
sec_t[iter].text_size_bytes = tng_fw_table[iter].header.data_location & data_loco;
sec_t[iter].text_size_dword = sec_t[iter].text_size_bytes >> 2;
sec_t[iter].data_size_dword = (tng_fw_table[iter].header.data_size + i_align) & (~i_align);
fwrite(&(sec_t[iter]), sizeof(struct fw_table_B0), 1, fp);
++iter;
}
iter = 0;
while (iter < FW_NUM) {
/* write text */
size = tng_fw_table[iter].header.text_size * 4;
fwrite(tng_fw_table[iter].fw_text, 1, size, fp);
for (i = 0; i < (sec_t[iter].text_size_bytes - size); i++)
fwrite(&pad_val, 1, 1, fp);
/* write data */
size = tng_fw_table[iter].header.data_size * 4;
fwrite(tng_fw_table[iter].fw_data, 1, size, fp);
for (i = 0; i < ((sec_t[iter].data_size_dword << 2) - size); i++)
fwrite(&pad_val, 1, 1, fp);
fflush(fp);
++iter;
}
return ;
}
int main()
{
FILE *fp = NULL;
fw_table_t topaz_fw_table[] = {
FW_MASTER_INFO(JPEG, JPEG), //FW_MASTER_JPEG = 0, //!< JPEG
FW_MASTER_INFO(H264_NO_RC, H264),//FW_MASTER_H264_NO_RC, //!< H264 with no rate control
FW_MASTER_INFO(H264_VBR, H264VBR),//FW_MASTER_H264_VBR, //!< H264 variable bitrate
FW_MASTER_INFO(H264_CBR, H264CBR),//FW_MASTER_H264_CBR, //!< H264 constant bitrate
FW_MASTER_INFO(H264_VCM, H264VCM),//FW_MASTER_H264_VCM, //!< H264 video conferance mode
FW_MASTER_INFO(H264_LLRC, H264LLRC),//FW_MASTER_H264_LLRC, //!< H264 low-latency rate control
FW_MASTER_INFO(H264ALL, H264ALL),
FW_MASTER_INFO(H263_NO_RC, H263),//FW_MASTER_H263_NO_RC, //!< H263 with no rate control
FW_MASTER_INFO(H263_VBR, H263VBR),//FW_MASTER_H263_VBR, //!< H263 variable bitrate
FW_MASTER_INFO(H263_CBR, H263CBR),//FW_MASTER_H263_CBR, //!< H263 constant bitrate
FW_MASTER_INFO(MPEG4_NO_RC, MPG4),//FW_MASTER_MPEG4_NO_RC, //!< MPEG4 with no rate control
FW_MASTER_INFO(MPEG4_VBR, MPG4VBR),//FW_MASTER_MPEG4_VBR, //!< MPEG4 variable bitrate
FW_MASTER_INFO(MPEG4_CBR, MPG4CBR),//FW_MASTER_MPEG4_CBR, //!< MPEG4 constant bitrate
FW_MASTER_INFO(MPEG2_NO_RC, MPG2),//FW_MASTER_MPEG2_NO_RC, //!< MPEG2 with no rate control
FW_MASTER_INFO(MPEG2_VBR, MPG2VBR),//FW_MASTER_MPEG2_VBR, //!< MPEG2 variable bitrate
FW_MASTER_INFO(MPEG2_CBR, MPG2CBR),//FW_MASTER_MPEG2_CBR, //!< MPEG2 constant bitrate
FW_MASTER_INFO(H264MVC_NO_RC, H264MVC),//FW_MASTER_H264MVC_NO_RC, //!< MVC H264 with no rate control
FW_MASTER_INFO(H264MVC_CBR, H264MVCCBR),//FW_MASTER_H264MVC_CBR, //!< MVC H264 constant bitrate
FW_MASTER_INFO(H264MVC_VBR, H264MVCVBR),//FW_MASTER_H264MVC_VBR, //!< MVC H264 variable bitrate
FW_MASTER_INFO(H264MVC_LLRC, H264MVCLLRC),//FW_MASTER_H264MVC_LLRC, //!< MVC H264 low-latency rate control
};
#ifdef B0_DEBUG
printf("fw_num is %d, fw = %d\n", FW_NUM, (int)sizeof(topaz_fw_table));
for(i = 0; i < FW_NUM; i++) {
topaz_fw_table[i].index = i;
topaz_fw_table[i].header.ver = FW_VER;
topaz_fw_table[i].header.codec = FW_MASTER_H264_NO_RC;
topaz_fw_table[i].header.text_size = 6883;
topaz_fw_table[i].header.data_size = 2997;
topaz_fw_table[i].header.data_location = 0x82886b90;
topaz_fw_table[i].fw_text = aui32H264_MasterMTXTOPAZFWText;
topaz_fw_table[i].fw_data = aui32H264_MasterMTXTOPAZFWData;
}
#endif
/* open file */
fp = fopen(FW_FILE_NAME_A0, "w");
if (NULL == fp)
return -1;
create_firmware_A0(topaz_fw_table, fp);
/* close file */
fclose(fp);
fp = fopen(FW_FILE_NAME_B0, "w");
if (NULL == fp)
return -1;
create_firmware_B0(topaz_fw_table, fp);
/* close file */
fclose(fp);
return 0;
}