index_header *
readIndex(const uint8 *buf) {
index_header *h;
const uint8 *sizeptr;
uint32 size, totsize;
uint32 i;
if ((uint32) MAKE_DWORD(buf[3], buf[2], buf[1], buf[0]) != 0xffffffff ||
MAKE_WORD(buf[5], buf[4]) != 0x0000) {
fprintf(stderr, "File is not a valid STRTAB file.\n");
exit(EXIT_FAILURE);
}
h = malloc(sizeof (index_header));
h->num_entries = MAKE_WORD(buf[7], buf[6]);
h->entries = malloc(h->num_entries * sizeof (entry_desc));
sizeptr = buf + 8;
if (MAKE_DWORD(sizeptr[3], sizeptr[2], sizeptr[1], sizeptr[0])) {
fprintf(stderr, "WARNING: Placeholder string entry hasn't got "
"size 0, but %d.\n",
MAKE_DWORD(sizeptr[3], sizeptr[2], sizeptr[1], sizeptr[0]));
}
sizeptr += 4;
totsize = 0;
for (i = 0; i < h->num_entries; i++) {
size = MAKE_DWORD(sizeptr[3], sizeptr[2], sizeptr[1], sizeptr[0]);
h->entries[i].size = size;
h->entries[i].offset = totsize;
sizeptr += 4;
totsize += size;
}
return h;
}
static void dump_service_loop(channel_node_t *p_node, u8 *p_data, u16 len)
{
u16 cnt = 0;
u8 loop = 0;
u16 desc_len = 0;
while(cnt < len)
{
p_node->svc[loop].s_id = MAKE_WORD(p_data[cnt + 1], p_data[cnt]);
cnt += 2;
p_node->svc[loop].pcr_pid = MAKE_WORD(p_data[cnt + 1], p_data[cnt]);
cnt += 2;
desc_len = MAKE_WORD(p_data[cnt + 1] , p_data[cnt] & 0xf);
cnt += 2;
if(desc_len > 0)
{
// dump service desc
dump_service_desc(&p_node->svc[loop], &p_data[cnt], desc_len);
cnt += desc_len;
}
desc_len = MAKE_WORD(p_data[cnt + 1] , p_data[cnt] & 0xf);
cnt += 2;
if(desc_len > 0)
{
// componet_loop
dump_component_loop(&p_node->svc[loop], &p_data[cnt], desc_len);
cnt += desc_len;
}
loop ++;
}
p_node->total_svc_num = loop;
}
static void dump_component_loop(channel_service_t *p_svc, u8 *p_data, u16 len)
{
u16 cnt = 0;
u16 desc_len = 0;
u8 num = 0;
while(cnt < len)
{
CH_DBG("tag %x, type %x pid %x \n",
p_data[cnt], p_data[cnt + 1], MAKE_WORD(p_data[cnt + 3] , p_data[cnt + 2]));
switch(p_data[cnt ])// tag
{
case 0: //video
p_svc->component[num].pid = MAKE_WORD(p_data[cnt + 3] , p_data[cnt + 2]);
p_svc->component[num].type = p_data[cnt + 1];
break;
case 1: // audio
p_svc->component[num].pid = MAKE_WORD(p_data[cnt + 3] , p_data[cnt + 2]);
p_svc->component[num].type = p_data[cnt + 1];
break;
default:
break;
}
cnt += 4;
desc_len = MAKE_WORD(p_data[cnt + 1] , p_data[cnt ] & 0xf);
cnt += 2;
if(desc_len > 0)
{
// component desc
dump_component_desc(&p_svc->component[num], &p_data[cnt], desc_len);
cnt += desc_len;
}
num ++;
}
p_svc->total_component_num = num;
}
static mulk_type_return_t read_gif_dim(const char *filename, int *width, int *height)
{
unsigned char buffer[GIF_HEADER_SIZE + GIF_DIM_SIZE], *dim;
mulk_type_return_t ret = MULK_RET_ERR;
size_t bytestoread;
FILE *file = NULL;
if ((file = fopen(filename, "rb")) == NULL)
return MULK_RET_FILE_ERR;
bytestoread = GIF_HEADER_SIZE + GIF_DIM_SIZE;
if (fread(buffer, 1, bytestoread, file) != bytestoread)
goto Exit;
if (memcmp(buffer, GIF_HEADER_VAL1, GIF_HEADER_SIZE)
&& memcmp(buffer, GIF_HEADER_VAL2, GIF_HEADER_SIZE))
goto Exit;
dim = buffer + GIF_HEADER_SIZE;
*width = MAKE_WORD(dim[1], dim[0]);
*height = MAKE_WORD(dim[3], dim[2]);
ret = MULK_RET_OK;
Exit:
fclose(file);
return ret;
}
static void get_upginfo_from_usb(u8 *buf,upg_info_t *upg_priv)
{
u8 *p_headr = NULL;
u8 i = 0;
u16 blk_num = 0;
u32 upginfo_off = 0;
p_headr = buf + 0x200000 + 16 + 8 +4;
blk_num = MAKE_WORD(*((buf) + 16 + 8 + 0x200000), *((buf) + 1 + 16 + 8 + 0x200000));
for(i = 0;i < blk_num;i++)
{
if(*p_headr == SYS_INFO_BLOCK_ID)
{
upginfo_off = MT_MAKE_DWORD(MAKE_WORD(*(p_headr + 4), *(p_headr + 5)),\
MAKE_WORD(*(p_headr + 6), *(p_headr + 7)));
OS_PRINTF("upginfo offset : %x \n",upginfo_off);
break;
}
else
{
p_headr += sizeof(dmh_block_info_t);
}
}
buf = buf + 0X200000 + upginfo_off;
get_upg_info(buf,upg_priv);
}
UINT8* UserPS_InitUniFontData(void)
{
PPSTORE_SECTION_HANDLE pSection;
UINT32 uiReadSize;
UINT8 *pMemPool;
get_blk((void *)&pMemPool, POOL_ID_CAPTURE);
rel_blk(POOL_ID_CAPTURE, pMemPool);
// Read Unicode font data from PStore to this memory pool
pMemPool = (pMemPool + POOL_SIZE_CAPTURE - POOL_SIZE_UNIFONT);
//PStore_EnablePS();
if((pSection = PStore_OpenSection(PS_UNIFONT_DATA, PS_RDONLY)) != E_PS_SECHDLER)
{
// Get Unicode font data size first (leading 4 bytes)
if(PStore_ReadSection(pMemPool, 0, 4, pSection) != E_PS_OK)
{
debug_err(("UserPS: PStore read Unicode font data size fail\r\n"));
return NULL;
}
uiReadSize = MAKE_LONG(MAKE_WORD(pMemPool[0], pMemPool[1]), MAKE_WORD(pMemPool[2], pMemPool[3]));
debug_err(("UserPS: Gotta read Unicode font data size = %ld\r\n", uiReadSize));
if(uiReadSize > POOL_SIZE_UNIFONT)
{
debug_err(("UserPS: Font data size too large!\r\n"));
return NULL;
}
// Get Unicode font data
if(PStore_ReadSection(pMemPool, 4, uiReadSize, pSection) != E_PS_OK)
{
debug_err(("UserPS: PStore read Unicode font data fail\r\n"));
return NULL;
}
PStore_CloseSection(pSection);
//PStore_DisablePS();
#if 0 //Just verify the data integrity
FilesysReadWriteByName2(FST_CMD_WRITE_BY_NAME, "A:\\VFONT.BIN", (UINT8 *)(pMemPool),
&uiReadSize, 0, FST_TIME_INFINITE);
#endif
}
else
{
debug_err(("UserPS: PStore open section fail\r\n"));
//PStore_DisablePS();
return NULL;
}
return pMemPool;
}
DECODE_REF
copen (PVOID InStream, STREAM_TYPE SType, STREAM_MODE SMode)
{
MEM_HANDLE h;
DWORD StreamLength;
_StreamType = SType;
_Stream = InStream;
if (SMode == STREAM_WRITE) /* writing */
{
OutChar (0); /* skip future StreamLength */
OutChar (0);
OutChar (0);
OutChar (0);
StreamLength = 0;
}
else /* reading */
{
BYTE lobyte, hibyte;
UWORD loword, hiword;
lobyte = (BYTE)InChar ();
hibyte = (BYTE)InChar ();
loword = MAKE_WORD (lobyte, hibyte);
lobyte = (BYTE)InChar ();
hibyte = (BYTE)InChar ();
hiword = MAKE_WORD (lobyte, hibyte);
StreamLength = MAKE_DWORD (loword, hiword);
}
h = 0;
if (StreamLength == 0xFFFFFFFF
|| (h = AllocCodeDesc ()) == 0
|| (_lpCurCodeDesc = LockCodeDesc (h)) == 0)
{
_lpCurCodeDesc = 0;
FreeCodeDesc (h);
}
else
{
_lpCurCodeDesc->fh = h;
_lpCurCodeDesc->Stream = _Stream;
_lpCurCodeDesc->StreamType = _StreamType;
_lpCurCodeDesc->StreamMode = SMode;
_lpCurCodeDesc->StreamLength = StreamLength;
_lpCurCodeDesc->buf_index = N - F;
memset ((PBYTE)&_lpCurCodeDesc->text_buf[0], ' ', N - F);
StartHuff ();
}
return ((DECODE_REF)_lpCurCodeDesc);
}
static void
init_probe (void)
{
BYTE b0, b1, b2, b3;
HSTARSHIP hStarShip;
b0 = GET_GAME_STATE (URQUAN_PROBE_GRPOFFS0);
b1 = GET_GAME_STATE (URQUAN_PROBE_GRPOFFS1);
b2 = GET_GAME_STATE (URQUAN_PROBE_GRPOFFS2);
b3 = GET_GAME_STATE (URQUAN_PROBE_GRPOFFS3);
GLOBAL (BattleGroupRef) = MAKE_DWORD (
MAKE_WORD (b0, b1), MAKE_WORD (b2, b3)
);
if (GLOBAL (BattleGroupRef) == 0)
{
CloneShipFragment (URQUAN_PROBE_SHIP,
&GLOBAL (npc_built_ship_q), 0);
GLOBAL (BattleGroupRef) = PutGroupInfo (~0L, 1);
b0 = LOBYTE (LOWORD (GLOBAL (BattleGroupRef)));
b1 = HIBYTE (LOWORD (GLOBAL (BattleGroupRef)));
b2 = LOBYTE (HIWORD (GLOBAL (BattleGroupRef)));
b3 = HIBYTE (HIWORD (GLOBAL (BattleGroupRef)));
SET_GAME_STATE (URQUAN_PROBE_GRPOFFS0, b0);
SET_GAME_STATE (URQUAN_PROBE_GRPOFFS1, b1);
SET_GAME_STATE (URQUAN_PROBE_GRPOFFS2, b2);
SET_GAME_STATE (URQUAN_PROBE_GRPOFFS3, b3);
}
if (!GET_GAME_STATE (PROBE_MESSAGE_DELIVERED)
&& GetGroupInfo (GLOBAL (BattleGroupRef), (BYTE)~0)
&& (hStarShip = GetHeadLink (
&GLOBAL (npc_built_ship_q)
)))
{
SHIP_FRAGMENTPTR FragPtr;
FragPtr = (SHIP_FRAGMENTPTR)LockStarShip (
&GLOBAL (npc_built_ship_q), hStarShip
);
SET_GROUP_MISSION (FragPtr, IN_ORBIT);
SET_GROUP_LOC (FragPtr, 2 + 1); /* orbitting earth */
SET_GROUP_DEST (FragPtr, 2 + 1); /* orbitting earth */
FragPtr->ShipInfo.loc.x = FragPtr->ShipInfo.loc.y = 0;
FragPtr->ShipInfo.group_counter = 0;
UnlockStarShip (
&GLOBAL (npc_built_ship_q), hStarShip
);
}
}
static void
dword_convert (DWORD *dword_array, COUNT num_dwords)
{
BYTE *p = (BYTE*)dword_array;
do
{
*dword_array++ = MAKE_DWORD (
MAKE_WORD (p[3], p[2]),
MAKE_WORD (p[1], p[0])
);
p += 4;
} while (--num_dwords);
}
static void _set_fp_display(char *content)
{
u32 data;
cmd_t cmd;
data = MT_MAKE_DWORD(MAKE_WORD(content[3], content[2]),
MAKE_WORD(content[1], content[0]));
cmd.id = AP_UIO_CMD_FP_DISPLAY;
cmd.data1 = data;
cmd.data2 = 4;
ap_frm_do_command(APP_UIO, &cmd);
}
uint8_t distco_update()
{
i2c_buf[1]=0xaf;
i2c_buf[2]=0xfe;
i2c_buf[3]=0xaf;
i2c_buf[4]=0xfe;
i2c_buf[5]=0xaf;
i2c_buf[6]=0xfe;
i2c_buf[7]=0xaf;
i2c_buf[8]=0xfe;
i2c_size = 9;
i2c_buf[0] = I2C_RX(DISTCO_I2C_ID);
if (!distco_transmit())
return 0;
distco_distance[0] = i2c_buf[1];
distco_distance[1] = i2c_buf[2];
distco_distance[2] = i2c_buf[3];
distco_distance[3] = i2c_buf[4];
distco_distance[4] = i2c_buf[5];
distco_rc5_count = i2c_buf[6];
uint16_t cmd = MAKE_WORD(i2c_buf[7], i2c_buf[8]);
if (cmd)
distco_rc5_cmd=cmd;
return 1;
}
static int aec6210_tune_chipset (ide_drive_t *drive, u8 xferspeed)
{
ide_hwif_t *hwif = HWIF(drive);
struct pci_dev *dev = hwif->pci_dev;
u16 d_conf = 0;
u8 speed = ide_rate_filter(aec62xx_ratemask(drive), xferspeed);
u8 ultra = 0, ultra_conf = 0;
u8 tmp0 = 0, tmp1 = 0, tmp2 = 0;
unsigned long flags;
local_irq_save(flags);
pci_read_config_word(dev, 0x40|(2*drive->dn), &d_conf);
tmp0 = pci_bus_clock_list(speed, BUSCLOCK(dev));
SPLIT_BYTE(tmp0,tmp1,tmp2);
MAKE_WORD(d_conf,tmp1,tmp2);
pci_write_config_word(dev, 0x40|(2*drive->dn), d_conf);
tmp1 = 0x00;
tmp2 = 0x00;
pci_read_config_byte(dev, 0x54, &ultra);
tmp1 = ((0x00 << (2*drive->dn)) | (ultra & ~(3 << (2*drive->dn))));
ultra_conf = pci_bus_clock_list_ultra(speed, BUSCLOCK(dev));
tmp2 = ((ultra_conf << (2*drive->dn)) | (tmp1 & ~(3 << (2*drive->dn))));
pci_write_config_byte(dev, 0x54, tmp2);
local_irq_restore(flags);
return(ide_config_drive_speed(drive, speed));
}
static void parse_cable_delivery_system_descriptor( u8* pBuf, cable_tp_info_t* pDesc )
{
u8* data = pBuf;
if( data != NULL && pDesc != NULL )
{
pDesc->frequency = make32(data);
pDesc->frequency = bcd_number_to_dec(pDesc->frequency)/10;
pDesc->modulation = data[6] + 3;
pDesc->symbol_rate = MT_MAKE_DWORD(
MAKE_WORD((data[10] & 0xf0), data[9]),
MAKE_WORD(data[8], data[7]));
//pDesc->symbol_rate >>= 8;
pDesc->symbol_rate = bcd_number_to_dec(pDesc->symbol_rate)/100;
}
}
static bool
GenerateRainbowWorld_generateOrbital (SOLARSYS_STATE *solarSys, PLANET_DESC *world)
{
if (matchWorld (solarSys, world, 0, MATCH_PLANET))
{
BYTE which_rainbow;
UWORD rainbow_mask;
STAR_DESC *SDPtr;
rainbow_mask = MAKE_WORD (
GET_GAME_STATE (RAINBOW_WORLD0),
GET_GAME_STATE (RAINBOW_WORLD1));
which_rainbow = 0;
SDPtr = &star_array[0];
while (SDPtr != CurStarDescPtr)
{
if (SDPtr->Index == RAINBOW_DEFINED)
++which_rainbow;
++SDPtr;
}
rainbow_mask |= 1 << which_rainbow;
SET_GAME_STATE (RAINBOW_WORLD0, LOBYTE (rainbow_mask));
SET_GAME_STATE (RAINBOW_WORLD1, HIBYTE (rainbow_mask));
}
GenerateDefault_generateOrbital (solarSys, world);
return true;
}
static COUNT
DeltaCredit (SIZE delta_credit)
{
COUNT Credit;
Credit = MAKE_WORD (
GET_GAME_STATE (MELNORME_CREDIT0),
GET_GAME_STATE (MELNORME_CREDIT1)
);
if ((int)delta_credit >= 0 || ((int)(-delta_credit) <= (int)(Credit)))
{
Credit += delta_credit;
SET_GAME_STATE (MELNORME_CREDIT0, LOBYTE (Credit));
SET_GAME_STATE (MELNORME_CREDIT1, HIBYTE (Credit));
LockMutex (GraphicsLock);
DrawStatusMessage ((UNICODE *)~0);
UnlockMutex (GraphicsLock);
}
else
{
NPCPhrase (NEED_MORE_CREDIT0);
NPCPhrase (delta_credit + (int)Credit);
NPCPhrase (NEED_MORE_CREDIT1);
}
return (Credit);
}
static BOOL parse_pat_m(class_handle_t handle, u8 *p_buf)
{
u8 *p_ptr = NULL;
u16 section_len = 0;
u16 prog_no = 0;
u16 pmt_pid = 0;
s16 program_len = 0;
m_svc_t *p_this = handle;
m_priv_t *p_priv = p_this->p_data;
MT_ASSERT(NULL != p_buf);
/* get section length */
section_len = MAKE_WORD(p_buf[2], (p_buf[1] & 0x0f));
section_len += 3;
program_len = (section_len - 8 - 4);
p_ptr = &p_buf[8];
while(program_len > 0)
{
/* get program number */
prog_no = MAKE_WORD(p_ptr[1], p_ptr[0]);
/* get program map pid */
pmt_pid = MAKE_WORD(p_ptr[3], (p_ptr[2] & 0x1f));
if (p_priv->param.s_id == prog_no)
{
p_priv->param.pmt_pid = pmt_pid;
return TRUE;
}
else if(p_priv->param.pmt_pid == pmt_pid
&& p_priv->param.s_id == 0x1fff)
{
p_priv->param.s_id = prog_no;
return TRUE;
}
program_len -= 4;
p_ptr += 4;
}
//p_priv->param.pmt_pid = 0x1FFF;
return FALSE;
}
static BOOL check_sec_crc(u8 *p_buffer)
{
u16 section_len = 0;
u32 crc = 0;
section_len = MAKE_WORD(p_buffer[2], (p_buffer[1] & 0x0f));
section_len += 3;
crc = crc_fast_calculate(CRC32_ARITHMETIC_CCITT,
0xFFFFFFFF, p_buffer, section_len - 4);
return (crc == make32(p_buffer + section_len -4));
}
static void
ExitConversation (RESPONSE_REF R)
{
if (PLAYER_SAID (R, bye))
{
setSegue (Segue_peace);
if (GET_GAME_STATE (GLOBAL_FLAGS_AND_DATA) & (1 << 7))
{
if (SlaveryCount)
{
UWORD PreviousSlaves;
PreviousSlaves = MAKE_WORD (
GET_GAME_STATE (CREW_SOLD_TO_DRUUGE0),
GET_GAME_STATE (CREW_SOLD_TO_DRUUGE1)
);
SlaveryCount += PreviousSlaves;
if (SlaveryCount > 250 && PreviousSlaves <= 250)
{
if (PreviousSlaves > 100)
GLOBAL (CrewCost) += (22 - 7);
else
GLOBAL (CrewCost) += 22;
}
else if (SlaveryCount > 100 && PreviousSlaves <= 100)
GLOBAL (CrewCost) += 7;
SET_GAME_STATE (CREW_SOLD_TO_DRUUGE0, LOBYTE (SlaveryCount));
SET_GAME_STATE (CREW_SOLD_TO_DRUUGE1, HIBYTE (SlaveryCount));
}
switch (GET_GAME_STATE (DRUUGE_HOME_VISITS))
{
case 1:
NPCPhrase (BYE_FROM_TRADE_WORLD_1);
break;
default:
NPCPhrase (BYE_FROM_TRADE_WORLD_2);
break;
}
}
else if (GET_GAME_STATE (GLOBAL_FLAGS_AND_DATA) & (1 << 6))
NPCPhrase (GOODBYE_FROM_BOMB_PLANET);
else
NPCPhrase (GOODBYE_FROM_SPACE);
}
else /* if (R == then_we_take_bomb) */
{
setSegue (Segue_hostile);
NPCPhrase (FIGHT_FOR_BOMB);
}
}
static BOOL monitor_data_get(class_handle_t handle, m_data_param_t *p_param)
{
m_svc_t *p_this = handle;
m_priv_t *p_priv = p_this->p_data;
u16 section_len = 0;
u8 *p_buffer = NULL;
u8 i = 0;
MT_ASSERT(p_param->t_id < M_MAX_TABLE);
p_buffer = (u8 *)p_priv->p_data_header[p_param->t_id].p_buffer;
if ((p_priv->state == MONITOR_RUNNING) &&
(p_priv->p_data_header[p_param->t_id].is_ready == TRUE))
{
m_svc_lock(handle);
if (p_param->type == M_SECTION_DATA)
{
section_len = MAKE_WORD(p_buffer[2], (p_buffer[1] & 0x0f));
section_len += 3;
memcpy(p_param->p_buffer, p_buffer, section_len);
}
else if (p_param->type == M_TABLE_DATA)
{
for (i = 0; i < p_priv->table_info[p_param->t_id].app_num; i++)
{
if (p_priv->table_info[p_param->t_id].app_info[i].app_id == p_param->ap_id)
{
p_priv->table_info[p_param->t_id].app_info[i].parse(handle, p_buffer, p_param->p_buffer);
}
}
}
else
{
OS_PRINTF("error data type!!!!");
MT_ASSERT(0);
}
m_svc_unlock(handle);
return TRUE;
}
else
{
for (i = 0; i < p_priv->table_info[p_param->t_id].app_num; i++)
{
if (p_priv->table_info[p_param->t_id].app_info[i].app_id == p_param->ap_id)
{
p_priv->table_info[p_param->t_id].app_info[i].get_flag = TRUE;
}
}
}
return FALSE;
}
void
writeSoundEntries(const index_header *h, const uint8 *buf, const char* outmask) {
FILE *out;
uint32 i;
char namebuf[512];
const uint8 *start;
uint8 *data;
const uint8 *orgdata;
uint32 datalen;
uint32 wavelen;
uint32 freq;
start = buf + 8 + (h->num_entries + 1) * 4;
data = NULL;
for (i = 0; i < h->num_entries; i++) {
sprintf(namebuf, "%s.%u.wav", outmask, i);
out = fopen(namebuf, "wb");
if (out == NULL) {
fprintf(stderr, "Could not open output file '%s': %s\n",
namebuf, strerror(errno));
exit(EXIT_FAILURE);
}
datalen = h->entries[i].size - 2;
data = realloc(data, datalen);
orgdata = start + h->entries[i].offset;
memcpy(data, orgdata, datalen);
signSoundBuf(data, datalen);
freq = MAKE_WORD(orgdata[datalen], orgdata[datalen + 1]);
wavelen = datalen + WAVEHDR_SIZE;
fputs(riffHdr, out);
writeFile_Int32_LE(out, wavelen);
fputs(waveType, out);
fputs(fmtHdr, out);
writeFile_Int32_LE(out, FMTHDR_SIZE);
writeFile_Int16_LE(out, 1); // format
writeFile_Int16_LE(out, 1); // channels
writeFile_Int32_LE(out, freq); // samples/sec
writeFile_Int32_LE(out, freq); // bytes/sec
writeFile_Int16_LE(out, 1); // block align
writeFile_Int16_LE(out, 8); // bits/sample
fputs(dataHdr, out);
writeFile_Int32_LE(out, datalen);
fwrite(data, 1, datalen, out);
fclose(out);
}
free(data);
}
static BOOL check_sec_crc(dvb_priv_t *p_priv, dvb_section_t *p_sec)
{
u16 section_len = 0;
u32 crc = 0;
section_len = MAKE_WORD(p_sec->p_buffer[2], (p_sec->p_buffer[1] & 0x0f));
section_len += 3;
crc = crc_fast_calculate(CRC32_ARITHMETIC_CCITT,
0xFFFFFFFF, (u8 *)p_sec->p_buffer, section_len - 4);
//OS_PRINTF("crc check error table_id 0x%x, value: 0x%x, value2 : 0x%x\n",
// p_sec->table_id, crc, make32(p_sec->p_buffer + section_len - 4));
return (crc == make32(p_sec->p_buffer + section_len -4));
}
CONTEXT
SetContext (CONTEXT Context)
{
CONTEXT LastContext;
LastContext = _pCurContext;
if (Context != LastContext)
{
if (LastContext)
{
UnsetContextFlags (
MAKE_WORD (0, GRAPHICS_ACTIVE | DRAWABLE_ACTIVE));
SetContextFlags (
MAKE_WORD (0, _GraphicsStatusFlags
& (GRAPHICS_ACTIVE | DRAWABLE_ACTIVE)));
DeactivateContext ();
}
_pCurContext = Context;
if (_pCurContext)
{
ActivateContext ();
_GraphicsStatusFlags &= ~(GRAPHICS_ACTIVE | DRAWABLE_ACTIVE);
_GraphicsStatusFlags |= HIBYTE (_get_context_flags ());
SetPrimColor (&_locPrim, _get_context_fg_color ());
_CurFramePtr = _get_context_fg_frame ();
_CurFontPtr = _get_context_font ();
}
}
return (LastContext);
}
static void dump_component_desc(component_desc_t *p_com, u8 *p_data, u16 len)
{
u16 cnt = 0;
u16 desc_len = 0;
while(cnt < len)
{
switch(p_data[cnt])
{
case CA_DESC_ID:
desc_len = p_data[cnt + 1];
p_com->cas.ca_sys_id = MAKE_WORD(p_data[cnt + 3], p_data[cnt + 2]);
p_com->cas.ca_pid = MAKE_WORD(p_data[cnt + 5], p_data[cnt + 4] & 0x1f);
CH_DBG("CA_DESC_ID 2 sys_id %d pid %d\n",
p_com->cas.ca_sys_id, p_com->cas.ca_pid);
break;
default:
break;
}
cnt += (p_data[cnt + 1] + 2);
}
}
static void monitor_data_save(class_handle_t handle, m_table_id_t t_id, u8 *p_buffer)
{
m_svc_t *p_this = handle;
m_priv_t *p_priv = p_this->p_data;
u8 i = 0;
u16 section_len = 0;
u8 ver = (p_buffer[5] & 0x3E) >> 1;
section_len = MAKE_WORD(p_buffer[2], (p_buffer[1] & 0x0f));
section_len += 3;
m_svc_lock(handle);
memcpy(p_priv->p_data_header[t_id].p_buffer, p_buffer, section_len);
m_svc_unlock(handle);
if (!p_priv->p_data_header[t_id].is_ready)
{
p_priv->p_data_header[t_id].is_ready = TRUE;
p_priv->table_info[t_id].version = ver;
for (i = 0; i < p_priv->table_info[t_id].app_num; i++)
{
if (p_priv->table_info[t_id].app_info[i].get_flag)
{
p_priv->table_info[t_id].app_info[i].get_flag = FALSE;
monitor_notify(p_priv->table_info[t_id].app_info[i].app_id, t_id, M_SVC_DATA_READY);
}
else
{
monitor_notify(p_priv->table_info[t_id].app_info[i].app_id, t_id, M_SVC_DATA_RESET);
}
}
}
else
{
if (ver != p_priv->table_info[t_id].version)
{
p_priv->table_info[t_id].version = ver;
for (i = 0; i < p_priv->table_info[t_id].app_num; i++)
{
monitor_notify(p_priv->table_info[t_id].app_info[i].app_id, t_id, M_SVC_VER_CHANGED);
}
}
}
}
static void dum_bouquet_list(channel_table_t *p_ch, u8 *p_data, u16 len)
{
u16 cnt = 0;
u16 name_len = 0;
u8 id = 0;
u8 num = 0;
while(cnt < len)
{
id = MAKE_WORD(p_data[cnt + 1], p_data[cnt]);
cnt += 2;
name_len = p_data[cnt];
cnt += 1;
p_ch->bouquet[num].id = id;
name_len = name_len > MAX_NAME_LEN ? MAX_NAME_LEN : name_len;
memcpy(p_ch->bouquet[num].name, &p_data[cnt], name_len);
CH_DBG("id %d len %d name %s\n", id, name_len, p_ch->bouquet[num].name);
cnt += name_len;
num ++;
}
p_ch->total_bouquet_num = num;
}
/**
* Re-compute the min value of children, return true if the value
* is changed.
*/
bool revisit(qc32s_node_t* curr, int32_t n)
{
while (true) {
// the word is volatile... get a safe copy of it via 64-bit
// atomic load
word64_t x;
mvx(&curr->word.all, &x.all);
// if the node is tentative, return
if (x.fields.word.bits.steady == TENTATIVE)
return (x.fields.min >= n);
// compute mvc: min value of children
//
// NB: we don't need to do atomic 64-bit reads if we are only
// working with an aligned 32-bit field within the packed
// struct
int32_t mvc = curr->my_num; // min value of all children
qc32s_node_t* begin = curr->first_child;
qc32s_node_t* end = curr->last_child;
if (begin != NULL) {
for (qc32s_node_t* n = begin; n <= end; n++) {
int32_t lmin = n->word.fields.min;
if (mvc > lmin)
mvc = lmin;
}
}
if (mvc < x.fields.min && mvc < n)
return false;
uint32_t aok = (mvc >= x.fields.min);
word64_t temp;
MAKE_WORD(temp, aok, mvc, x.fields.word.bits.ver + 1);
if (bcas64(&curr->word.all, x.all, temp.all))
return (x.fields.min >= n);
}
}
static void dump_transport_desc(channel_node_t *p_node, u8 *p_data, u16 len)
{
u16 cnt = 0;
u16 desc_len = 0;
while(cnt < len)
{
switch(p_data[cnt])
{
case CA_DESC_ID:
CH_DBG("CA_DESC_ID \n");
desc_len = p_data[cnt + 1];
p_node->cas.ca_sys_id = MAKE_WORD(p_data[cnt + 3], p_data[cnt + 2]);
p_node->cas.ca_pid = MAKE_WORD(p_data[cnt + 5], p_data[cnt + 4] & 0x1f);
break;
case DVB_DESC_CABLE_DELIVERY:
CH_DBG("DVB_DESC_CABLE_DELIVERY \n");
desc_len = p_data[cnt + 1];
p_node->cable.freq = MT_MAKE_DWORD(MAKE_WORD(p_data[cnt + 5], p_data[cnt + 4]), \
MAKE_WORD(p_data[cnt + 3], p_data[cnt + 2]));
p_node->cable.modulation = p_data[cnt + 8];
p_node->cable.sym = MT_MAKE_DWORD(MAKE_WORD(p_data[cnt + 12], p_data[cnt + 11]), \
MAKE_WORD(p_data[cnt + 10], p_data[cnt + 9] & 0xf));
CH_DBG("freq %d sym %d mod %d\n",
p_node->cable.freq, p_node->cable.sym, p_node->cable.modulation);
break;
case 0x90: //bouquet_list_descriptor
{
CH_DBG("bouquet_list_descriptor \n");
desc_len = p_data[cnt + 1];
if(desc_len > 0)
{
dum_bouquet_list(p_table, &p_data[cnt + 2], desc_len);
}
}
break;
default:
break;
}
cnt += (p_data[cnt + 1] + 2);
}
}
bit configSetStartupConfig()
{
byte commands = 0;
byte index;
word addr;
wait_ms(5);
i2cFlag = I2C_READ | I2C_START | I2C_STOP | I2C_WORD_ADDR_TYPE;
SET_I2C(EEPROM_I2C_ADDR, TX_CONFIG_OFFSET+CONF_NUM_CMDS_OFFSEET, &commands, 1, i2cFlag);
if(!devRomFunction(ROM_I2C_ACCESS))
return FALSE;
if(!commands || commands > 62)
return FALSE;
wait_ms(5);
for(index=1; index<=commands; index++) {
addr = TX_CONFIG_OFFSET+(8*index);
i2cFlag = I2C_READ | I2C_START | I2C_STOP | I2C_WORD_ADDR_TYPE;
SET_I2C(EEPROM_I2C_ADDR, addr, &buff_request, 8, i2cFlag);
if(!devRomFunction(ROM_I2C_ACCESS))
return FALSE;
wait_ms(5);
si47xx_command(8, buff_request, 8, buff_response);
// if(buff_ret != SI4711_OK)
// return FALSE;
/* wait for tSTC and tCOMP */
switch(buff_request[0]) {
case TX_TUNE_FREQ:
wait_ms(100);
break;
case TX_TUNE_POWER:
wait_ms(20);
if(buff_request[3] >= 88) {
TxPoweredUp = TRUE;
} else {
TXLed = LED_OFF;
TxPoweredUp = FALSE;
ASQLOWLed = LED_OFF;
ASQHILed = LED_OFF;
ASQOVRMLed = LED_OFF;
}
break;
case SET_PROPERTY:
wait_ms(10);
if(buff_request[2] == 0x21 &&
buff_request[3] == 0x01) {
DeviationValueThatSet = MAKE_WORD(buff_request[4], buff_request[5]);
DeviationValueCounted = DeviationValueThatSet;
}
break;
default:
wait_ms(5);
break;
}
}
//set audio config after it!
si47xxSetAudio(TRUE);
// if(buff_ret != SI4711_OK)
// return FALSE;
return TRUE;
}
void READ_ASQ_STATUS()
{
byte status=0;
//bit old_val;
if(!FePoweredUp)
return;
asq_delayed++;
if(asq_delayed < 10000)
return;
asq_delayed=0;
FELed = !FELed;
buff_request[0] = GET_INT_STATUS;
si47xx_command(1, buff_request, 1, &status);
if(!(status & CTS) || (status & ERR)) {
FELed = !FELed;
return;
}
if(status & STCINT) {
buff_request[0] = TX_TUNE_STATUS;
buff_request[1] = TX_TUNE_STATUS_IN_INTACK;
si47xx_command(2, buff_request, 7, buff_response);
if(!(buff_response[0] & CTS) || (buff_response[0] & ERR)) {
FELed = !FELed;
return;
}
TxFreq = MAKE_WORD(buff_response[2],buff_response[3]);
TxPower = buff_response[5];
TxAntCap = buff_response[6];
TxRnl = buff_response[7];
if(TxFreq && TxPower)
TXLed = LED_ON;
else
TXLed = LED_OFF;
}
if(!TxPoweredUp)
return;
buff_request[0] = TX_ASQ_STATUS;
/* if interrupt, then clean counters,
* in other case, just read current level */
if(status & ASQINT)
buff_request[1] = TX_ASQ_STATUS_IN_INTACK;
else
buff_request[1] = 0x00;
si47xx_command(2, buff_request, 5, buff_response);
if(!(buff_response[0] & CTS) || (buff_response[0] & ERR)) {
FELed = !FELed;
return;
}
asq_level = buff_response[4];
if(status & ASQINT) {
asq_overmod = buff_response[1] & TX_ASQ_STATUS_OUT_OVERMOD;
asq_iall = buff_response[1] & TX_ASQ_STATUS_OUT_IALL;
asq_ialh = buff_response[1] & TX_ASQ_STATUS_OUT_IALH;
ASQLOWLed = asq_iall ? LED_ON : LED_OFF;
ASQHILed = asq_ialh ? LED_ON : LED_OFF;
ASQOVRMLed = asq_overmod ? LED_ON : LED_OFF;
}
//old_val = ASQLOWLed;
//ASQLOWLed = ASQHILed = ASQOVRMLed = !old_val;
}
/*===================================================================
IEP3_HID(): Prepare Data to send from SI4711 to PC through IEP3 HID
===================================================================*/
void HID_ACCESS()
{
#ifdef _HID_
if ( (PCCommand == PCTransfer) && !(PCRequest&RequestDone) ) {
switch (PCRequest) {
case(RequestSi4711Reset):
//bReportOut:
// +-----------+-----------+
// | PCCommand | PCRequest |
// +-----------+-----------+
si47xxReset();
break;
case(RequestCpuId):
// +-----------+-----------+--------------+----------+-------------+----------+---------------+
// | PCCommand | PCRequest | REV_MINOR[2] | STR_SIZE | REV_MAJOR[] | STR_SIZE | DEVICE_NAME[] |
// +-----------+-----------+--------------+----------+-------------+----------+---------------+
Xdata.InEp3.HidReport.bReportItem[2] = (0xFF00 & REVISION_MAJOR) >> 8;
Xdata.InEp3.HidReport.bReportItem[3] = 0x00FF & REVISION_MAJOR;
Xdata.InEp3.HidReport.bReportItem[4] = sizeof(REVISION_MINOR);
AppDevice.dummy.bData[0] = 0;
for(AppDevice.dummy.bData[0] = 0;
AppDevice.dummy.bData[0] < sizeof(REVISION_MINOR);
AppDevice.dummy.bData[0]++)
Xdata.InEp3.HidReport.bReportItem[5 + AppDevice.dummy.bData[0]] =
REVISION_MINOR[AppDevice.dummy.bData[0]];
Xdata.InEp3.HidReport.bReportItem[5 + AppDevice.dummy.bData[0]] = sizeof(DEVICE_NAME);
AppDevice.dummy.bData[1] = AppDevice.dummy.bData[0] + 5 + 1;
for(AppDevice.dummy.bData[0] = 0;
AppDevice.dummy.bData[0] < sizeof(DEVICE_NAME);
AppDevice.dummy.bData[0]++)
Xdata.InEp3.HidReport.bReportItem[AppDevice.dummy.bData[1] + AppDevice.dummy.bData[0]] =
DEVICE_NAME[AppDevice.dummy.bData[0]];
break;
case(RequestSi4711PowerStatus):
// +-----------+-----------+-------------+----------------+
// | PCCommand | PCRequest | IsPoweredUp | IsTransmitting |
// +-----------+-----------+-------------+----------------+
Xdata.InEp3.HidReport.bReportItem[2] = FePoweredUp;
Xdata.InEp3.HidReport.bReportItem[3] = TxPoweredUp;
break;
case(RequestSi4711PowerUp):
if(FePoweredUp) {
PCCommand |= PCRequestError;
break;
} else {
FePoweredUp=TRUE;
}
//bReportOut:
// +-----------+-----------+---------+-----------+
// | PCCommand | PCRequest | IsError | ErrorCode |
// +-----------+-----------+---------+-----------+
buff_ret = SI4711_COMM_ERR;
Xdata.InEp3.HidReport.bReportItem[3] = 1;
si47xxPowerUp();
if(!(buff_response[0] & CTS)) {
Xdata.InEp3.HidReport.bReportItem[2] = buff_ret;
break;
}
buff_ret = SI4711_COMM_ERR;
Xdata.InEp3.HidReport.bReportItem[3] = 2;
si47xxFMTX_hardware_cfg();
Xdata.InEp3.HidReport.bReportItem[2] = buff_ret;
FELed = LED_ON;
break;
case(RequestSi4711PowerDown):
if(!FePoweredUp) {
PCCommand |= PCRequestError;
break;
}
//bReportOut:
// +-----------+-----------+---------+-----------+
// | PCCommand | PCRequest | IsError | ErrorCode |
// +-----------+-----------+---------+-----------+
buff_ret = SI4711_COMM_ERR;
si47xxPowerDown();
if(buff_ret != SI4711_OK || !(buff_response[0] & CTS)) {
Xdata.InEp3.HidReport.bReportItem[2] = buff_ret;
si47xxReset(); //force!
}
break;
case(RequestSi4711AudioEnable):
if(!FePoweredUp) {
PCCommand |= PCRequestError;
break;
}
buff_ret = SI4711_COMM_ERR;
si47xxSetAudio(TRUE);
Xdata.InEp3.HidReport.bReportItem[2] = buff_ret;
break;
case(RequestSi4711AudioDisable):
if(!FePoweredUp) {
PCCommand |= PCRequestError;
break;
}
buff_ret = SI4711_COMM_ERR;
si47xxSetAudio(FALSE);
Xdata.InEp3.HidReport.bReportItem[2] = buff_ret;
break;
case(RequestEepromSectionRead):
//bReportOut:
// +-----------+-----------+---------+-------+
// | PCCommand | PCRequest | Offset | bytes |
// +-----------+-----------+---------+-------+
if(Xdata.OutEp4.HidOReport.bReportOut[4] > 32) {
PCCommand |= PCRequestError;
break;
}
AppDevice.dummy.wData[0] =
MAKE_WORD(Xdata.OutEp4.HidOReport.bReportOut[2], Xdata.OutEp4.HidOReport.bReportOut[3]);
if(AppDevice.dummy.wData[0] + Xdata.OutEp4.HidOReport.bReportOut[4] > 0x2000) {
PCCommand |= PCRequestError;
break;
}
i2cFlag = I2C_READ | I2C_START | I2C_STOP | I2C_WORD_ADDR_TYPE;
SET_I2C(EEPROM_I2C_ADDR, AppDevice.dummy.wData[0],
&Xdata.InEp3.HidReport.bReportItem[3],
Xdata.OutEp4.HidOReport.bReportOut[4], i2cFlag);
Xdata.InEp3.HidReport.bReportItem[2] = devRomFunction(ROM_I2C_ACCESS);
//bReportItem:
// +-----------+-----------+--------+---------+- ... -+---------+
// | PCCommand | PCRequest | status | data[0] | ... | data[n] |
// +-----------+-----------+--------+---------+- ... -+---------+
break;
case(RequestEepromSectionWrite):
//bReportOut:
// +-----------+-----------+---------+-------+---------+- ... -+---------+
// | PCCommand | PCRequest | Offset | bytes | data[0] | ... | data[n] |
// +-----------+-----------+---------+-------+---------+- ... -+---------+
if(Xdata.OutEp4.HidOReport.bReportOut[4] > 32) {
PCCommand |= PCRequestError;
break;
}
AppDevice.dummy.wData[0] =
MAKE_WORD(Xdata.OutEp4.HidOReport.bReportOut[2], Xdata.OutEp4.HidOReport.bReportOut[3]);
if(AppDevice.dummy.wData[0] + Xdata.OutEp4.HidOReport.bReportOut[4] > 0x2000) {
PCCommand |= PCRequestError;
break;
}
i2cFlag = I2C_WRITE | I2C_START | I2C_STOP | I2C_WORD_ADDR_TYPE;
SET_I2C(EEPROM_I2C_ADDR, AppDevice.dummy.wData[0],
&Xdata.OutEp4.HidOReport.bReportOut[5],
Xdata.OutEp4.HidOReport.bReportOut[4], i2cFlag);
Xdata.InEp3.HidReport.bReportItem[2] = devRomFunction(ROM_I2C_ACCESS);
//bReportItem:
// +-----------+-----------+--------+
// | PCCommand | PCRequest | status |
// +-----------+-----------+--------+
break;
case(RequestSi4711SetProp):
if(!FePoweredUp) {
PCCommand |= PCRequestError;
break;
}
//bReportOut:
// +-----------+-----------+---------+
// | PCCommand | PCRequest | IsError |
// +-----------+-----------+---------+
//reversal order here
AppDevice.dummy.wData[0] =
MAKE_WORD(Xdata.OutEp4.HidOReport.bReportOut[2], Xdata.OutEp4.HidOReport.bReportOut[3]);
//must set other way
if(AppDevice.dummy.wData[0] == REFCLK_PRESCALE ||
AppDevice.dummy.wData[0] == REFCLK_FREQ ||
AppDevice.dummy.wData[0] == DIGITAL_INPUT_FORMAT ||
AppDevice.dummy.wData[0] == DIGITAL_INPUT_SAMPLE_RATE ||
AppDevice.dummy.wData[0] == GPO_IEN) {
Xdata.InEp3.HidReport.bReportItem[2] = SI4711_BAD_ARG;
PCCommand |= PCRequestError;
break;
}
AppDevice.dummy.wData[1] =
MAKE_WORD(Xdata.OutEp4.HidOReport.bReportOut[4], Xdata.OutEp4.HidOReport.bReportOut[5]);
buff_ret = SI4711_COMM_ERR;
Xdata.InEp3.HidReport.bReportItem[6] =
si47xx_set_property(AppDevice.dummy.wData[0], AppDevice.dummy.wData[1]);
Xdata.InEp3.HidReport.bReportItem[7] = buff_response[0];
Xdata.InEp3.HidReport.bReportItem[8] = buff_ret;
Xdata.InEp3.HidReport.bReportItem[2] = Xdata.OutEp4.HidOReport.bReportOut[2];
Xdata.InEp3.HidReport.bReportItem[3] = Xdata.OutEp4.HidOReport.bReportOut[3];
Xdata.InEp3.HidReport.bReportItem[4] = Xdata.OutEp4.HidOReport.bReportOut[4];
Xdata.InEp3.HidReport.bReportItem[5] = Xdata.OutEp4.HidOReport.bReportOut[5];
// hack for set volume
if(AppDevice.dummy.wData[0] == TX_AUDIO_DEVIATION) {
DeviationValueThatSet = AppDevice.dummy.wData[1];
coSpkUpdate();
}
//bReportOut:
// +-----------+-----------+---------+------------+------+------+
// | PCCommand | PCRequest | IsError | IsErrorGet | ValH | ValL |
// +-----------+-----------+---------+------------+------+------+
#ifndef _PROP_RECHECK_ //re-check out property!
AppDevice.dummy.wData[1] = 0;
break;
#endif
case(RequestSi4711GetProp):
if(!FePoweredUp) {
PCCommand |= PCRequestError;
break;
}
//bReportOut:
// +-----------+-----------+---------+
// | PCCommand | PCRequest | IsError |
// +-----------+-----------+---------+
AppDevice.dummy.wData[0] =
MAKE_WORD(Xdata.OutEp4.HidOReport.bReportOut[2], Xdata.OutEp4.HidOReport.bReportOut[3]);
AppDevice.dummy.wData[1] = 0;
buff_ret = SI4711_COMM_ERR;
Xdata.InEp3.HidReport.bReportItem[6] =
si47xx_get_property(AppDevice.dummy.wData[0], &AppDevice.dummy.wData[1]);
Xdata.InEp3.HidReport.bReportItem[7] = buff_response[0];
Xdata.InEp3.HidReport.bReportItem[8] = buff_ret;
Xdata.InEp3.HidReport.bReportItem[2] = Xdata.OutEp4.HidOReport.bReportOut[2];
Xdata.InEp3.HidReport.bReportItem[3] = Xdata.OutEp4.HidOReport.bReportOut[3];
Xdata.InEp3.HidReport.bReportItem[4] = MSB(AppDevice.dummy.wData[1]);
Xdata.InEp3.HidReport.bReportItem[5] = LSB(AppDevice.dummy.wData[1]);
break;
case(RequestSi4711Access):
if(!FePoweredUp) {
PCCommand |= PCRequestError;
break;
}
Xdata.InEp3.HidReport.bReportItem[2] = 0;
Xdata.InEp3.HidReport.bReportItem[3] = 0;
Xdata.InEp3.HidReport.bReportItem[4] = 0;
if(Xdata.OutEp4.HidOReport.bReportOut[2] < 1) {
PCCommand |= PCRequestError;
Xdata.InEp3.HidReport.bReportItem[2] = FALSE;
Xdata.InEp3.HidReport.bReportItem[3] = SI4711_BAD_ARG;
break;
}
//bReportOut:
// +-----------+-----------+---------+---------+--------+- ... -+--------+
// | PCCommand | PCRequest | ArgsLen | Command | Arg[1] | ... | Arg[7] |
// +-----------+-----------+---------+---------+--------+- ... -+--------+
//bReportItem:
// +-----------+-----------+-------------+------------+---------+---------+---------+ ... -+----------+
// | PCCommand | PCRequest | WriteStatus | ReadStatus | RespLen | Status | Resp[1] | ... | Resp[15] |
// +-----------+-----------+-------------+------------+---------+---------+---------+ ... -+----------+
//do it other way!
if(Xdata.OutEp4.HidOReport.bReportOut[3] == POWER_UP ||
Xdata.OutEp4.HidOReport.bReportOut[3] == POWER_DOWN ||
Xdata.OutEp4.HidOReport.bReportOut[3] == TX_ASQ_STATUS ||
Xdata.OutEp4.HidOReport.bReportOut[3] == TX_TUNE_STATUS ||
Xdata.OutEp4.HidOReport.bReportOut[3] == SET_PROPERTY ||
Xdata.OutEp4.HidOReport.bReportOut[3] == GET_PROPERTY ) {
Xdata.InEp3.HidReport.bReportItem[2] = FALSE;
Xdata.InEp3.HidReport.bReportItem[3] = SI4711_BAD_ARG;
break;
}
/* Write command */
Xdata.InEp3.HidReport.bReportItem[4] = 16; // RespLen
buff_ret = SI4711_COMM_ERR;
Xdata.InEp3.HidReport.bReportItem[2] = si47xx_command(Xdata.OutEp4.HidOReport.bReportOut[2], &Xdata.OutEp4.HidOReport.bReportOut[3],
Xdata.InEp3.HidReport.bReportItem[4], &Xdata.InEp3.HidReport.bReportItem[5]);
Xdata.InEp3.HidReport.bReportItem[3] = buff_ret;
/* Set specific delay, depends on what command sent. */
if(Xdata.OutEp4.HidOReport.bReportOut[3] == TX_TUNE_POWER) {
if(Xdata.OutEp4.HidOReport.bReportOut[6] >= 88) {
TxPoweredUp = TRUE;
} else {
// TXLed = LED_OFF;
TxPoweredUp = FALSE;
ASQLOWLed = LED_OFF;
ASQHILed = LED_OFF;
ASQOVRMLed = LED_OFF;
}
}
Xdata.InEp3.HidReport.bReportItem[21] = AppDevice.spk.preVol[DEV_SPK_LEFT_CN];
Xdata.InEp3.HidReport.bReportItem[22] = AppDevice.spk.preVol[DEV_SPK_RIGHT_CN];
Xdata.InEp3.HidReport.bReportItem[23] = MSB(DeviationValueCounted);
Xdata.InEp3.HidReport.bReportItem[24] = LSB(DeviationValueCounted);
break;
case(RequestSi4711AsqStatus):
if(!FePoweredUp || !TxPoweredUp) {
PCCommand |= PCRequestError;
break;
}
//bReportOut:
// +-----------+-----------+---------+---------+------+------+-------+
// | PCCommand | PCRequest | IsError | overmod | iall | ialh | level |
// +-----------+-----------+---------+---------+------+------+-------+
Xdata.InEp3.HidReport.bReportItem[2] = 0x00;
Xdata.InEp3.HidReport.bReportItem[3] = asq_overmod;
Xdata.InEp3.HidReport.bReportItem[4] = asq_iall;
Xdata.InEp3.HidReport.bReportItem[5] = asq_ialh;
Xdata.InEp3.HidReport.bReportItem[6] = asq_level;
break;
case(RequestSi4711TuneStatus):
if(!FePoweredUp) {
PCCommand |= PCRequestError;
break;
}
//bReportOut:
// +-----------+-----------+---------+---------+---------+-------+--------+-----+
// | PCCommand | PCRequest | IsError | FREQ[m] | FREQ[l] | power | antcap | rnl |
// +-----------+-----------+---------+---------+---------+-------+--------+-----+
Xdata.InEp3.HidReport.bReportItem[2] = 0x00;
Xdata.InEp3.HidReport.bReportItem[3] = MSB(TxFreq);
Xdata.InEp3.HidReport.bReportItem[4] = LSB(TxFreq);
Xdata.InEp3.HidReport.bReportItem[5] = TxPower;
Xdata.InEp3.HidReport.bReportItem[6] = TxAntCap;
Xdata.InEp3.HidReport.bReportItem[7] = TxRnl;
break;
default:
PCCommand |= PCRequestError;
break;
}
// send data to PC through USP HID
PCRequest |= RequestDone;
Xdata.InEp3.HidReport.bReportItem[0] = PCCommand;
Xdata.InEp3.HidReport.bReportItem[1] = PCRequest;
while (!(IEPDCNTX3&0x80));
IEPDCNTX3 = sizeof(Xdata.InEp3.HidReport);
}
#endif
}
