//------------------------------------------------------------------------------
//!
void
BIH::create(
const Vector<AABBoxf*>& bboxes,
const Vector<Vec3f>& centers,
Vector<uint>* ids,
uint leafSize,
uint maxDepth
)
{
CHECK( bboxes.size() == centers.size() );
DBG_BLOCK( os_bih, "Start computing BIH..." );
DBG( Timer timer );
// Initialization.
DBG_MSG( os_bih, "# of elements: " << bboxes.size() << " " << centers.size() << "\n" );
// 1. Init maximum recursion level.
if( maxDepth == 0 )
{
maxDepth = (int)CGM::log2( float(centers.size()) ) * 2 + 1;
}
_maxDepth = CGM::min( maxDepth, (uint)100 );
// 2. Init ids.
if( ids == 0 )
{
_ids.resize( centers.size() );
for( uint i = 0; i < _ids.size(); ++i )
{
_ids[i] = i;
}
}
else
{
_ids.swap( *ids );
}
Vector<uint> remap( centers.size() );
for( uint i = 0; i < remap.size(); ++i )
{
remap[i] = i;
}
// 3. Init nodes and root.
//_nodes.reserve();
_nodes.resize(1);
// 4. Compute bounding box.
AABBoxf nodeBox = AABBoxf::empty();
for( uint i = 0; i < bboxes.size(); ++i )
{
nodeBox |= *bboxes[i];
}
AABBoxf splitBox = nodeBox;
// 5. Stack.
Vector<BuildStackNode> stack( maxDepth );
uint stackID = 0;
uint maxPrim = 0;
uint maxD = 0;
// Construct BIH.
uint begin = 0;
uint end = uint(_ids.size());
uint depth = 1;
uint node = 0;
while( 1 )
{
// Do we have a root node?
if( (end - begin <= leafSize) || depth >= maxDepth )
{
// Root node.
_nodes[node]._index = (begin << 3) + 3;
_nodes[node]._numElements = end-begin;
maxPrim = CGM::max( maxPrim, end-begin );
maxD = CGM::max( maxD, depth );
// Are we done?
if( stackID == 0 )
{
break;
}
stack[--stackID].get( node, begin, end, depth, nodeBox, splitBox );
}
else
{
// Compute split plane and axis.
uint axis = splitBox.longestSide();
float splitPlane = splitBox.center( axis );
// Partition primitives.
AABBoxf leftNodeBox = AABBoxf::empty();
AABBoxf rightNodeBox = AABBoxf::empty();
uint pivot = begin;
for( uint i = begin; i < end; ++i )
{
if( centers[remap[i]](axis) < splitPlane )
{
leftNodeBox |= (*bboxes[remap[i]]);
CGM::swap( remap[i], remap[pivot] );
CGM::swap( _ids[i], _ids[pivot++] );
}
else
{
rightNodeBox |= (*bboxes[remap[i]]);
}
}
// Construct node.
++depth;
// No left node.
if( pivot == begin )
{
uint childNode = uint(_nodes.size());
// Current node.
_nodes[node]._index = (childNode << 3) + 4 + axis;
_nodes[node]._plane[0] = rightNodeBox.min( axis );
_nodes[node]._plane[1] = rightNodeBox.max( axis );
// Create nodes.
_nodes.pushBack( Node() );
// Child node.
node = childNode;
nodeBox = rightNodeBox;
splitBox.slab( axis )(0) = CGM::max( splitPlane, rightNodeBox.min( axis ) );
}
// No right node.
else if( pivot == end )
{
uint childNode = uint(_nodes.size());
// Current node.
_nodes[node]._index = (childNode << 3) + 4 + axis;
_nodes[node]._plane[0] = leftNodeBox.min( axis );
_nodes[node]._plane[1] = leftNodeBox.max( axis );
// Create nodes.
_nodes.pushBack( Node() );
// Child node.
node = childNode;
nodeBox = leftNodeBox;
splitBox.slab( axis )(1) = CGM::min( splitPlane, leftNodeBox.max( axis ) );
}
// Left and right node.
else
{
uint leftNode = uint(_nodes.size());
// Current node.
_nodes[node]._index = (leftNode << 3) + axis;
_nodes[node]._plane[0] = leftNodeBox.max( axis );
_nodes[node]._plane[1] = rightNodeBox.min( axis );
// Create nodes.
_nodes.pushBack( Node() );
_nodes.pushBack( Node() );
// Right node.
AABBoxf rsplitBox( splitBox );
rsplitBox.slab( axis )(0) = splitPlane;
stack[stackID++].set( leftNode+1, pivot, end, depth, rightNodeBox, rsplitBox );
// Left node.
node = leftNode;
end = pivot;
nodeBox = leftNodeBox;
splitBox.slab( axis )(1) = splitPlane;
}
}
}
DBG( double time = timer.elapsed() );
DBG_MSG( os_bih, "...finish in " << time << " sec." );
DBG_MSG( os_bih, "# of nodes: " << _nodes.size() );
DBG_MSG( os_bih, "# of indices: " << _ids.size() );
DBG_MSG( os_bih, "max primitives in a leaf: " << maxPrim );
DBG_MSG( os_bih, "max depth: " << maxD << " " << maxDepth );
}
/*
* Build the list with footnote text information for Word 8/9/10 files
*/
static void
vGet8FootnotesText(FILE *pFile, const pps_info_type *pPPS,
const ULONG *aulBBD, size_t tBBDLen,
const ULONG *aulSBD, size_t tSBDLen,
const UCHAR *aucHeader)
{
footnote_local_type *pCurr;
const ULONG *aulBlockDepot;
UCHAR *aucBuffer;
ULONG ulCharPos, ulBeginOfFootnotes, ulOffset, ulBeginFootnoteText;
size_t tFootnoteTextLen, tBlockDepotLen, tBlockSize;
size_t tIndex;
TRACE_MSG("vGet8FootnotesText");
ulBeginOfFootnotes = ulGetLong(0x18, aucHeader); /* fcMin */
ulBeginOfFootnotes += ulGetLong(0x4c, aucHeader); /* ccpText */
NO_DBG_HEX(ulBeginOfFootnotes);
ulBeginFootnoteText = ulGetLong(0xb2, aucHeader); /* fcPlcffndTxt */
NO_DBG_HEX(ulBeginFootnoteText);
tFootnoteTextLen =
(size_t)ulGetLong(0xb6, aucHeader); /* lcbPlcffndTxt */
NO_DBG_DEC(tFootnoteTextLen);
if (tFootnoteTextLen < 12) {
DBG_MSG("No Footnote text in this document");
return;
}
NO_DBG_DEC(pPPS->tTable.ulSB);
NO_DBG_HEX(pPPS->tTable.ulSize);
if (pPPS->tTable.ulSize == 0) {
DBG_MSG("No footnote text information");
return;
}
if (pPPS->tTable.ulSize < MIN_SIZE_FOR_BBD_USE) {
/* Use the Small Block Depot */
aulBlockDepot = aulSBD;
tBlockDepotLen = tSBDLen;
tBlockSize = SMALL_BLOCK_SIZE;
} else {
/* Use the Big Block Depot */
aulBlockDepot = aulBBD;
tBlockDepotLen = tBBDLen;
tBlockSize = BIG_BLOCK_SIZE;
}
aucBuffer = xmalloc(tFootnoteTextLen);
if (!bReadBuffer(pFile, pPPS->tTable.ulSB,
aulBlockDepot, tBlockDepotLen, tBlockSize,
aucBuffer, ulBeginFootnoteText, tFootnoteTextLen)) {
aucBuffer = xfree(aucBuffer);
return;
}
NO_DBG_PRINT_BLOCK(aucBuffer, tFootnoteTextLen);
fail(tFootnoteTextLength != 0);
tFootnoteTextLength = tFootnoteTextLen / 4 - 2;
fail(tFootnoteTextLength == 0);
fail(pFootnoteText != NULL);
pFootnoteText = xcalloc(tFootnoteTextLength,
sizeof(footnote_local_type));
for (tIndex = 0; tIndex < tFootnoteTextLength; tIndex++) {
pCurr = pFootnoteText + tIndex;
pCurr->tInfo.szText = NULL;
ulOffset = ulGetLong(tIndex * 4, aucBuffer);
NO_DBG_HEX(ulOffset);
ulCharPos = ulBeginOfFootnotes + ulOffset;
NO_DBG_HEX(ulCharPos);
NO_DBG_HEX(ulCharPos2FileOffset(ulCharPos));
pCurr->ulCharPosStart = ulCharPos;
ulOffset = ulGetLong(tIndex * 4 + 4, aucBuffer);
NO_DBG_HEX(ulOffset);
ulCharPos = ulBeginOfFootnotes + ulOffset;
NO_DBG_HEX(ulCharPos);
NO_DBG_HEX(ulCharPos2FileOffset(ulCharPos));
pCurr->ulCharPosNext = ulCharPos;
pCurr->bUseful = pCurr->ulCharPosStart != pCurr->ulCharPosNext;
}
aucBuffer = xfree(aucBuffer);
} /* end of vGet8FootnotesText */
/*
* Build the list with endnote information for Word 8/9/10 files
*/
static void
vGet8EndnotesInfo(FILE *pFile, const pps_info_type *pPPS,
const ULONG *aulBBD, size_t tBBDLen,
const ULONG *aulSBD, size_t tSBDLen,
const UCHAR *aucHeader)
{
const ULONG *aulBlockDepot;
UCHAR *aucBuffer;
ULONG ulFileOffset, ulBeginOfText, ulOffset, ulBeginEndnoteInfo;
size_t tEndnoteInfoLen, tBlockDepotLen, tBlockSize;
size_t tIndex;
TRACE_MSG("vGet8EndnotesInfo");
ulBeginOfText = ulGetLong(0x18, aucHeader); /* fcMin */
NO_DBG_HEX(ulBeginOfText);
ulBeginEndnoteInfo = ulGetLong(0x20a, aucHeader); /* fcPlcfendRef */
NO_DBG_HEX(ulBeginEndnoteInfo);
tEndnoteInfoLen = (size_t)ulGetLong(0x20e, aucHeader); /* lcbPlcfendRef */
NO_DBG_DEC(tEndnoteInfoLen);
if (tEndnoteInfoLen < 10) {
DBG_MSG("No endnotes in this document");
return;
}
NO_DBG_DEC(pPPS->tTable.ulSB);
NO_DBG_HEX(pPPS->tTable.ulSize);
if (pPPS->tTable.ulSize == 0) {
DBG_MSG("No endnotes information");
return;
}
if (pPPS->tTable.ulSize < MIN_SIZE_FOR_BBD_USE) {
/* Use the Small Block Depot */
aulBlockDepot = aulSBD;
tBlockDepotLen = tSBDLen;
tBlockSize = SMALL_BLOCK_SIZE;
} else {
/* Use the Big Block Depot */
aulBlockDepot = aulBBD;
tBlockDepotLen = tBBDLen;
tBlockSize = BIG_BLOCK_SIZE;
}
aucBuffer = xmalloc(tEndnoteInfoLen);
if (!bReadBuffer(pFile, pPPS->tTable.ulSB,
aulBlockDepot, tBlockDepotLen, tBlockSize,
aucBuffer, ulBeginEndnoteInfo, tEndnoteInfoLen)) {
aucBuffer = xfree(aucBuffer);
return;
}
NO_DBG_PRINT_BLOCK(aucBuffer, tEndnoteInfoLen);
fail(tEndnoteListLength != 0);
tEndnoteListLength = (tEndnoteInfoLen - 4) / 6;
fail(tEndnoteListLength == 0);
fail(aulEndnoteList != NULL);
aulEndnoteList = xcalloc(tEndnoteListLength, sizeof(ULONG));
for (tIndex = 0; tIndex < tEndnoteListLength; tIndex++) {
ulOffset = ulGetLong(tIndex * 4, aucBuffer);
NO_DBG_HEX(ulOffset);
ulFileOffset = ulCharPos2FileOffset(ulBeginOfText + ulOffset);
NO_DBG_HEX(ulFileOffset);
aulEndnoteList[tIndex] = ulFileOffset;
}
aucBuffer = xfree(aucBuffer);
} /* end of vGet8EndnotesInfo */
INT32 Lens_Init(LENS_INIT_STATE part)
{
INT32 ERROR_STATUS;
switch(part)
{
case LENS_INIT_ZOOM_PART1:
//Step 1. Initiate zoom part1
DBG_MSG("Start of LENS_INIT_ZOOM_PART1\r\n");
//Callback function
//TM_Begin(LENS_ZOOM_INIT);
if(gLensCtrlObj.APICB!=NULL)
{
gLensCtrlObj.APICB(LENS_CB_INITZOOM1_START, NULL);
}
gLensCtrlObj.pLens->zoom_initPart1();
//Callback function
if(gLensCtrlObj.APICB!=NULL)
{
gLensCtrlObj.APICB(LENS_CB_INITZOOM1_END, NULL);
}
Lens_Module_SetState(LENS_STATE_INIT_PART1);
DBG_MSG("End of LENS_STATE_INIT_PART1\r\n"); // --> LENS_STATE_INIT_PART1
return ERR_OK;
case LENS_INIT_ZOOM_PART2:
//Step 2. Initiate zoom part2
DBG_MSG("Start of LENS_INIT_ZOOM_PART2\r\n");
//TM_Begin(LENS_ZOOM_INITWAIT);
//Callback function
if(gLensCtrlObj.APICB!=NULL)
{
gLensCtrlObj.APICB(LENS_CB_INITZOOM2_START, NULL);
}
ERROR_STATUS = gLensCtrlObj.pLens->zoom_initPart2();
//Callback function
if(gLensCtrlObj.APICB!=NULL)
{
gLensCtrlObj.APICB(LENS_CB_INITZOOM2_END, NULL);
}
//TM_End(LENS_ZOOM_INITWAIT);
DBG_MSG("End of LENS_INIT_ZOOM_PART2\r\n");
return ERROR_STATUS;
case LENS_INIT_APERTURE:
//Step 3. Initiate aperture
DBG_MSG("Start of LENS_INIT_APERTURE\r\n");
//TM_Begin(LENS_APER_INIT);
//Callback function
if(gLensCtrlObj.APICB!=NULL)
{
gLensCtrlObj.APICB(LENS_CB_INITAPERTURE_START, NULL);
}
gLensCtrlObj.pLens->aperture_init();
//#NT#2010/09/23#Jeffery Chuang -begin
//Add shutter init here until add new api
gLensCtrlObj.pMotor->shutter_setState(MOTOR_SHUTTER_NORMAL,OPEN);
//#NT#2010/09/23#Jeffery Chuang -end
//Callback function
if(gLensCtrlObj.APICB!=NULL)
{
gLensCtrlObj.APICB(LENS_CB_INITAPERTURE_END, NULL);
}
//TM_End(LENS_APER_INIT);
DBG_MSG("End of LENS_INIT_APERTURE\r\n");
return ERR_OK;
case LENS_INIT_FOCUS:
//TM_Begin(LENS_FOCUS_INIT);
DBG_MSG("Start of LENS_INIT_FOCUS\r\n");
//Callback function
if(gLensCtrlObj.APICB!=NULL)
{
gLensCtrlObj.APICB(LENS_CB_INITFOCUS_START, NULL);
}
#if 1 // Could be migrated to other place in the near future.
{
PPSTORE_SECTION_HANDLE pSection;
INT16 iTmpIdx[15] = {0};
UINT32 uiCalTblSize = Lens_Zoom_GetSection(ZOOM_MAX_SECTION)/* Table size of DemoKit is '11'. */, i;
if(sizeof(iTmpIdx) >= uiCalTblSize)
{
if ((pSection = PStore_OpenSection(PS_FOCUS_DATA, PS_RDWR)) != E_PS_SECHDLER)
{
PStore_ReadSection((UINT8 *)&iTmpIdx, 0, uiCalTblSize * sizeof(INT16), pSection);
PStore_CloseSection(pSection);
for(i = 0; i < uiCalTblSize; i++)
{
DBG_MSG("^GZoom sec_%d: peak_idx:%d\r\n", i+1, iTmpIdx[i]);
}
Lens_Focus_SetCalData(iTmpIdx, uiCalTblSize);
}
else
DBG_ERR("No focus calibration data!\r\n");
}
else
{
DBG_ERR("Buf size isn't enough for AF cal data!\r\n");
}
}
#endif
gLensCtrlObj.pLens->makeAFTable();
ERROR_STATUS = gLensCtrlObj.pLens->focus_init();
//Callback function
if(gLensCtrlObj.APICB!=NULL)
{
gLensCtrlObj.APICB(LENS_CB_INITFOCUS_END, NULL);
}
Lens_Module_SetState(LENS_STATE_IDLE);
DBG_MSG("LENS_STATE_IDLE\r\n"); // --> LENS_STATE_IDLE
DBG_MSG("End of LENS_INIT_FOCUS\r\n");
//TM_End(LENS_FOCUS2_INIT);
return ERROR_STATUS;
default:
DBG_ERR("Init wrong state\r\n");
return ERR_OPERATION_FAIL;
}
}
/*
* Fill the font information block with information
* from a WinWord 1 file.
*/
void
vGet1FontInfo(int iFodo,
const UCHAR *aucGrpprl, size_t tBytes, font_block_type *pFont)
{
BOOL bIcoChange, bFtcChange, bHpsChange, bKulChange;
USHORT usTmp;
UCHAR ucTmp;
UCHAR aucChpx[12];
fail(iFodo < 0 || aucGrpprl == NULL || pFont == NULL);
if (tBytes > sizeof(aucChpx)) {
NO_DBG_PRINT_BLOCK(aucGrpprl + iFodo, tBytes);
return;
}
/* Build the CHPX structure */
(void)memset(aucChpx, 0, sizeof(aucChpx));
(void)memcpy(aucChpx, aucGrpprl + iFodo, min(tBytes, sizeof(aucChpx)));
usTmp = usGetWord(0, aucChpx);
if ((usTmp & BIT(0)) != 0) {
pFont->usFontStyle ^= FONT_BOLD;
}
if ((usTmp & BIT(1)) != 0) {
pFont->usFontStyle ^= FONT_ITALIC;
}
if ((usTmp & BIT(2)) != 0) {
pFont->usFontStyle ^= FONT_STRIKE;
}
if ((usTmp & BIT(5)) != 0) {
pFont->usFontStyle ^= FONT_SMALL_CAPITALS;
}
if ((usTmp & BIT(6)) != 0) {
pFont->usFontStyle ^= FONT_CAPITALS;
}
if ((usTmp & BIT(7)) != 0) {
pFont->usFontStyle ^= FONT_HIDDEN;
}
ucTmp = ucGetByte(5, aucChpx);
if (ucTmp != 0) {
if (ucTmp < 128) {
pFont->usFontStyle |= FONT_SUPERSCRIPT;
DBG_MSG("Superscript");
} else {
pFont->usFontStyle |= FONT_SUBSCRIPT;
DBG_MSG("Subscript");
}
}
bIcoChange = (usTmp & BIT(10)) != 0;
bFtcChange = (usTmp & BIT(11)) != 0;
bHpsChange = (usTmp & BIT(12)) != 0;
bKulChange = (usTmp & BIT(13)) != 0;
if (bFtcChange) {
usTmp = usGetWord(2, aucChpx);
if (usTmp <= (USHORT)UCHAR_MAX) {
pFont->ucFontNumber = (UCHAR)usTmp;
} else {
pFont->ucFontNumber = 0;
}
}
if (bHpsChange) {
pFont->usFontSize = (USHORT)ucGetByte(4, aucChpx);
}
if (bIcoChange || bKulChange) {
usTmp = usGetWord(6, aucChpx);
if (bIcoChange) {
pFont->ucFontColor = (UCHAR)((usTmp & 0x0f00) >> 8);
if (pFont->ucFontColor <= 7) {
/* Add 1 for compatibility with Word 2 and up */
pFont->ucFontColor++;
} else {
DBG_DEC(pFont->ucFontColor);
pFont->ucFontColor = 0;
}
}
if (bKulChange) {
usTmp = (usTmp & 0x7000) >> 12;
DBG_DEC_C(usTmp > 4, usTmp);
if (usTmp == 0) {
pFont->usFontStyle &= ~FONT_UNDERLINE;
} else {
pFont->usFontStyle |= FONT_UNDERLINE;
}
}
}
int vout_info_add_entry(vout_t *vo)
{
vout_info_t *p;
int i;
if( vo->inf == 0 )
return 0;
#ifdef CONFIG_HW_GOVR2_DVO
switch( vo->inf->mode ){
case VOUT_INF_DVI:
vo->govr = p_govrh2;
break;
default:
vo->govr = p_govrh;
break;
}
#else
vo->govr = ( (vo->inf->mode == VOUT_INF_DVI) && g_vpp.dual_display )? p_govrh2:p_govrh;
#endif
for(i=0;i<VPP_VOUT_INFO_NUM;i++){
p = &vout_info[i];
p->num = i;
if( p->vo_mask == 0 ){
break;
}
if( p->vo_mask & (0x1 << vo->num) ){
return i;
}
if( vo->govr ){
if( p->govr_mod == ((vpp_mod_base_t *)(vo->govr))->mod ){
goto add_entry_exist;
}
}
}
if( i >= VPP_VOUT_INFO_NUM ){
DBG_ERR("full\n");
goto add_entry_exist;
return VPP_VOUT_INFO_NUM;
}
if( (g_vpp.dual_display == 0) && (i!=0) ){
p->resx = vout_info[0].resx;
p->resy = vout_info[0].resy;
}
else {
p->resx = vo->resx;
p->resy = vo->resy;
}
p->resx_virtual = vpp_calc_align(p->resx,4);
p->resy_virtual = p->resy;
p->fps = (int) vo->pixclk;
p->govr_mod = (vo->govr)? ((vpp_mod_base_t *)vo->govr)->mod:VPP_MOD_MAX;
p->govr = vo->govr;
add_entry_exist:
p->vo_mask |= (0x1 << vo->num);
DBG_MSG("info %d,vo mask 0x%x,%s,%dx%d@%d\n",i,p->vo_mask,vpp_mod_str[p->govr_mod],p->resx,p->resy,p->fps);
return i;
}
static void level1_cache_flush_all(void)
{
DBG_MSG(4, ("meson_drm_ump_osk_msync(): Flushing the whole L1 cache\n"));
__cpuc_flush_kern_all();
}
int ump_dmabuf_import_wrapper(u32 __user *argument,
struct ump_session_data *session_data)
{
ump_session_memory_list_element *session = NULL;
struct ump_uk_dmabuf ump_dmabuf;
ump_dd_handle *ump_handle;
ump_dd_physical_block *blocks;
struct dma_buf_attachment *attach;
struct dma_buf *dma_buf;
struct sg_table *sgt;
struct scatterlist *sgl;
unsigned long block_size;
/* FIXME */
struct device dev;
unsigned int i = 0, npages;
int ret;
/* Sanity check input parameters */
if (!argument || !session_data) {
MSG_ERR(("NULL parameter.\n"));
return -EINVAL;
}
if (copy_from_user(&ump_dmabuf, argument,
sizeof(struct ump_uk_dmabuf))) {
MSG_ERR(("copy_from_user() failed.\n"));
return -EFAULT;
}
dma_buf = dma_buf_get(ump_dmabuf.fd);
if (IS_ERR(dma_buf))
return PTR_ERR(dma_buf);
/*
* check whether dma_buf imported already exists or not.
*
* TODO
* if already imported then dma_buf_put() should be called
* and then just return dma_buf imported.
*/
attach = dma_buf_attach(dma_buf, &dev);
if (IS_ERR(attach)) {
ret = PTR_ERR(attach);
goto err_dma_buf_put;
}
sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
if (IS_ERR(sgt)) {
ret = PTR_ERR(sgt);
goto err_dma_buf_detach;
}
npages = sgt->nents;
/* really need? */
ump_dmabuf.ctx = (void *)session_data;
block_size = sizeof(ump_dd_physical_block) * npages;
blocks = (ump_dd_physical_block *)_mali_osk_malloc(block_size);
if (NULL == blocks) {
MSG_ERR(("Failed to allocate blocks\n"));
ret = -ENOMEM;
goto err_dmu_buf_unmap;
}
sgl = sgt->sgl;
while (i < npages) {
blocks[i].addr = sg_phys(sgl);
blocks[i].size = sg_dma_len(sgl);
sgl = sg_next(sgl);
i++;
}
/*
* Initialize the session memory list element, and add it
* to the session object
*/
session = _mali_osk_calloc(1, sizeof(*session));
if (!session) {
DBG_MSG(1, ("Failed to allocate session.\n"));
ret = -EFAULT;
goto err_free_block;
}
ump_handle = ump_dd_handle_create_from_phys_blocks(blocks, i);
if (UMP_DD_HANDLE_INVALID == ump_handle) {
DBG_MSG(1, ("Failed to create ump handle.\n"));
ret = -EFAULT;
goto err_free_session;
}
session->mem = (ump_dd_mem *)ump_handle;
_mali_osk_lock_wait(session_data->lock, _MALI_OSK_LOCKMODE_RW);
_mali_osk_list_add(&(session->list),
&(session_data->list_head_session_memory_list));
_mali_osk_lock_signal(session_data->lock, _MALI_OSK_LOCKMODE_RW);
_mali_osk_free(blocks);
ump_dmabuf.ump_handle = (uint32_t)ump_handle;
ump_dmabuf.size = ump_dd_size_get(ump_handle);
if (copy_to_user(argument, &ump_dmabuf,
sizeof(struct ump_uk_dmabuf))) {
MSG_ERR(("copy_to_user() failed.\n"));
ret = -EFAULT;
goto err_release_ump_handle;
}
return 0;
err_release_ump_handle:
ump_dd_reference_release(ump_handle);
err_free_session:
_mali_osk_free(session);
err_free_block:
_mali_osk_free(blocks);
err_dmu_buf_unmap:
dma_buf_unmap_attachment(attach, sgt, DMA_BIDIRECTIONAL);
err_dma_buf_detach:
dma_buf_detach(dma_buf, attach);
err_dma_buf_put:
dma_buf_put(dma_buf);
return ret;
}
/*
* IOCTL operation; Import fd to UMP memory
*/
int ump_ion_import_wrapper(u32 __user * argument, struct ump_session_data * session_data)
{
_ump_uk_ion_import_s user_interaction;
ump_dd_handle *ump_handle;
ump_dd_physical_block * blocks;
unsigned long num_blocks;
struct ion_handle *ion_hnd;
struct scatterlist *sg;
struct scatterlist *sg_ion;
unsigned long i = 0;
ump_session_memory_list_element * session_memory_element = NULL;
if (ion_client_ump==NULL)
ion_client_ump = ion_client_create(ion_exynos, -1, "ump");
/* Sanity check input parameters */
if (NULL == argument || NULL == session_data)
{
MSG_ERR(("NULL parameter in ump_ioctl_allocate()\n"));
return -ENOTTY;
}
/* Copy the user space memory to kernel space (so we safely can read it) */
if (0 != copy_from_user(&user_interaction, argument, sizeof(user_interaction)))
{
MSG_ERR(("copy_from_user() in ump_ioctl_allocate()\n"));
return -EFAULT;
}
user_interaction.ctx = (void *) session_data;
/* translate fd to secure ID*/
ion_hnd = ion_import_fd(ion_client_ump, user_interaction.ion_fd);
sg_ion = ion_map_dma(ion_client_ump,ion_hnd);
blocks = (ump_dd_physical_block*)_mali_osk_malloc(sizeof(ump_dd_physical_block)*1024);
if (NULL == blocks) {
MSG_ERR(("Failed to allocate blocks in ump_ioctl_allocate()\n"));
return -ENOMEM;
}
sg = sg_ion;
do {
blocks[i].addr = sg_phys(sg);
blocks[i].size = sg_dma_len(sg);
i++;
if (i>=1024) {
_mali_osk_free(blocks);
MSG_ERR(("ion_import fail() in ump_ioctl_allocate()\n"));
return -EFAULT;
}
sg = sg_next(sg);
} while(sg);
num_blocks = i;
/* Initialize the session_memory_element, and add it to the session object */
session_memory_element = _mali_osk_calloc( 1, sizeof(ump_session_memory_list_element));
if (NULL == session_memory_element)
{
_mali_osk_free(blocks);
DBG_MSG(1, ("Failed to allocate ump_session_memory_list_element in ump_ioctl_allocate()\n"));
return -EFAULT;
}
ump_handle = ump_dd_handle_create_from_phys_blocks(blocks, num_blocks);
if (UMP_DD_HANDLE_INVALID == ump_handle)
{
_mali_osk_free(session_memory_element);
_mali_osk_free(blocks);
DBG_MSG(1, ("Failed to allocate ump_session_memory_list_element in ump_ioctl_allocate()\n"));
return -EFAULT;
}
session_memory_element->mem = (ump_dd_mem*)ump_handle;
_mali_osk_lock_wait(session_data->lock, _MALI_OSK_LOCKMODE_RW);
_mali_osk_list_add(&(session_memory_element->list), &(session_data->list_head_session_memory_list));
_mali_osk_lock_signal(session_data->lock, _MALI_OSK_LOCKMODE_RW);
ion_unmap_dma(ion_client_ump,ion_hnd);
ion_free(ion_client_ump, ion_hnd);
_mali_osk_free(blocks);
user_interaction.secure_id = ump_dd_secure_id_get(ump_handle);
user_interaction.size = ump_dd_size_get(ump_handle);
user_interaction.ctx = NULL;
if (0 != copy_to_user(argument, &user_interaction, sizeof(user_interaction)))
{
/* If the copy fails then we should release the memory. We can use the IOCTL release to accomplish this */
MSG_ERR(("copy_to_user() failed in ump_ioctl_allocate()\n"));
return -EFAULT;
}
return 0; /* success */
}
_mali_osk_errcode_t _ump_ukk_allocate( _ump_uk_allocate_s *user_interaction )
{
ump_session_data * session_data = NULL;
ump_dd_mem *new_allocation = NULL;
ump_session_memory_list_element * session_memory_element = NULL;
int map_id;
DEBUG_ASSERT_POINTER( user_interaction );
DEBUG_ASSERT_POINTER( user_interaction->ctx );
session_data = (ump_session_data *) user_interaction->ctx;
session_memory_element = _mali_osk_calloc( 1, sizeof(ump_session_memory_list_element));
if (NULL == session_memory_element)
{
DBG_MSG(1, ("Failed to allocate ump_session_memory_list_element in ump_ioctl_allocate()\n"));
return _MALI_OSK_ERR_NOMEM;
}
new_allocation = _mali_osk_calloc( 1, sizeof(ump_dd_mem));
if (NULL==new_allocation)
{
_mali_osk_free(session_memory_element);
DBG_MSG(1, ("Failed to allocate ump_dd_mem in _ump_ukk_allocate()\n"));
return _MALI_OSK_ERR_NOMEM;
}
/* Create a secure ID for this allocation */
_mali_osk_lock_wait(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
map_id = ump_descriptor_mapping_allocate_mapping(device.secure_id_map, (void*)new_allocation);
if (map_id < 0)
{
_mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
_mali_osk_free(session_memory_element);
_mali_osk_free(new_allocation);
DBG_MSG(1, ("Failed to allocate secure ID in ump_ioctl_allocate()\n"));
return - _MALI_OSK_ERR_INVALID_FUNC;
}
/* Initialize the part of the new_allocation that we know so for */
new_allocation->secure_id = (ump_secure_id)map_id;
_mali_osk_atomic_init(&new_allocation->ref_count,1);
if ( 0==(UMP_REF_DRV_UK_CONSTRAINT_USE_CACHE & user_interaction->constraints) )
new_allocation->is_cached = 0;
else new_allocation->is_cached = 1;
/* special case a size of 0, we should try to emulate what malloc does in this case, which is to return a valid pointer that must be freed, but can't be dereferences */
if (0 == user_interaction->size)
{
user_interaction->size = 1; /* emulate by actually allocating the minimum block size */
}
new_allocation->size_bytes = UMP_SIZE_ALIGN(user_interaction->size); /* Page align the size */
new_allocation->lock_usage = UMP_NOT_LOCKED;
/* Now, ask the active memory backend to do the actual memory allocation */
if (!device.backend->allocate( device.backend->ctx, new_allocation ) )
{
DBG_MSG(3, ("OOM: No more UMP memory left. Failed to allocate memory in ump_ioctl_allocate(). Size: %lu, requested size: %lu\n", new_allocation->size_bytes, (unsigned long)user_interaction->size));
ump_descriptor_mapping_free(device.secure_id_map, map_id);
_mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
_mali_osk_free(new_allocation);
_mali_osk_free(session_memory_element);
return _MALI_OSK_ERR_INVALID_FUNC;
}
new_allocation->hw_device = _UMP_UK_USED_BY_CPU;
new_allocation->ctx = device.backend->ctx;
new_allocation->release_func = device.backend->release;
_mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
/* Initialize the session_memory_element, and add it to the session object */
session_memory_element->mem = new_allocation;
_mali_osk_lock_wait(session_data->lock, _MALI_OSK_LOCKMODE_RW);
_mali_osk_list_add(&(session_memory_element->list), &(session_data->list_head_session_memory_list));
_mali_osk_lock_signal(session_data->lock, _MALI_OSK_LOCKMODE_RW);
user_interaction->secure_id = new_allocation->secure_id;
user_interaction->size = new_allocation->size_bytes;
DBG_MSG(3, ("UMP memory allocated. ID: %u, size: %lu\n", new_allocation->secure_id, new_allocation->size_bytes));
return _MALI_OSK_ERR_OK;
}
UMP_KERNEL_API_EXPORT ump_dd_handle ump_dd_handle_create_from_phys_blocks(ump_dd_physical_block * blocks, unsigned long num_blocks)
{
ump_dd_mem * mem;
unsigned long size_total = 0;
int map_id;
u32 i;
/* Go through the input blocks and verify that they are sane */
for (i=0; i < num_blocks; i++)
{
unsigned long addr = blocks[i].addr;
unsigned long size = blocks[i].size;
DBG_MSG(5, ("Adding physical memory to new handle. Address: 0x%08lx, size: %lu\n", addr, size));
size_total += blocks[i].size;
if (0 != UMP_ADDR_ALIGN_OFFSET(addr))
{
MSG_ERR(("Trying to create UMP memory from unaligned physical address. Address: 0x%08lx\n", addr));
return UMP_DD_HANDLE_INVALID;
}
if (0 != UMP_ADDR_ALIGN_OFFSET(size))
{
MSG_ERR(("Trying to create UMP memory with unaligned size. Size: %lu\n", size));
return UMP_DD_HANDLE_INVALID;
}
}
/* Allocate the ump_dd_mem struct for this allocation */
mem = _mali_osk_malloc(sizeof(*mem));
if (NULL == mem)
{
DBG_MSG(1, ("Could not allocate ump_dd_mem in ump_dd_handle_create_from_phys_blocks()\n"));
return UMP_DD_HANDLE_INVALID;
}
/* Find a secure ID for this allocation */
_mali_osk_lock_wait(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
map_id = ump_descriptor_mapping_allocate_mapping(device.secure_id_map, (void*) mem);
if (map_id < 0)
{
_mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
_mali_osk_free(mem);
DBG_MSG(1, ("Failed to allocate secure ID in ump_dd_handle_create_from_phys_blocks()\n"));
return UMP_DD_HANDLE_INVALID;
}
/* Now, make a copy of the block information supplied by the user */
mem->block_array = _mali_osk_malloc(sizeof(ump_dd_physical_block)* num_blocks);
if (NULL == mem->block_array)
{
ump_descriptor_mapping_free(device.secure_id_map, map_id);
_mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
_mali_osk_free(mem);
DBG_MSG(1, ("Could not allocate a mem handle for function ump_dd_handle_create_from_phys_blocks().\n"));
return UMP_DD_HANDLE_INVALID;
}
_mali_osk_memcpy(mem->block_array, blocks, sizeof(ump_dd_physical_block) * num_blocks);
/* And setup the rest of the ump_dd_mem struct */
_mali_osk_atomic_init(&mem->ref_count, 1);
mem->secure_id = (ump_secure_id)map_id;
mem->size_bytes = size_total;
mem->nr_blocks = num_blocks;
mem->backend_info = NULL;
mem->ctx = NULL;
mem->release_func = phys_blocks_release;
/* For now UMP handles created by ump_dd_handle_create_from_phys_blocks() is forced to be Uncached */
mem->is_cached = 0;
mem->hw_device = _UMP_UK_USED_BY_CPU;
mem->lock_usage = UMP_NOT_LOCKED;
_mali_osk_lock_signal(device.secure_id_map_lock, _MALI_OSK_LOCKMODE_RW);
DBG_MSG(3, ("UMP memory created. ID: %u, size: %lu\n", mem->secure_id, mem->size_bytes));
return (ump_dd_handle)mem;
}
void Power_StopUSBCharge(void)
{
//DBG_MSG(" gIsUSBInsert=%d,gIsBattInsert=%d,gIsBattDead=%d,gIsUSBAdapter=%d\r\n",gIsUSBInsert,gIsBattInsert,gIsBattDead,gIsUSBAdapter);
if (!gIsBattInsert)
{
DBG_DUMP(" NO Battery, Ignore STOP\r\n");
return;
}
#if _MIPS_TODO
//#NT#2010/12/10#Jeah Yen -begin
if((USB_GetSource() == USB_SRC_USB_ADAPTER) && (Power_GetSource() != POWER_SRC_USB_ADAPTER))
{
//Not charge yet, just start check low-battery
DBG_DUMP("GxPower: Start low-battery check.\r\n");
GxPower_SetControl(GXPWR_CTRL_BATTERY_DETECT_EN, TRUE);
}
//#NT#2010/12/10#Jeah Yen -end
//#NT#2011/3/30#Jeah Yen -begin
if((USB_GetSource() == USB_SRC_NONE) && (Power_GetSource() != POWER_SRC_USB_ADAPTER))
{
//Cannot charge, start check low-battery
DBG_DUMP("GxPower: Start low-battery check.\r\n");
GxPower_SetControl(GXPWR_CTRL_BATTERY_DETECT_EN, TRUE);
}
//#NT#2011/3/30#Jeah Yen -end
if((USB_GetSource() == USB_SRC_USB_ADAPTER))
{
//DBG_MSG(" USB Src = Adaptor\r\n");
GxPower_SetControl(GXPWR_CTRL_BATTERY_CHARGE_CURRENT,BATT_CHARGE_CURRENT_LOW);
DBG_MSG(" Charge Current = %d\r\n", BATT_CHARGE_CURRENT_LOW);
}
#endif
if((USB_GetSource() == USB_SRC_USB_PC))
{
//DBG_MSG(" USB Src = PC\r\n");
GxPower_SetControl(GXPWR_CTRL_BATTERY_CHARGE_CURRENT,BATT_CHARGE_CURRENT_LOW);
DBG_MSG(" Charge Current = %d\r\n", BATT_CHARGE_CURRENT_LOW);
}
if (!GxPower_GetControl(GXPWR_CTRL_BATTERY_CHARGE_EN))
{
DBG_DUMP(" Already NOT Charge, Ignore STOP\r\n");
return;
}
//#NT#2010/12/10#Jeah Yen -begin
DBG_DUMP("GxPower: Stop to Charge Battery\r\n");
GxPower_SetControl(GXPWR_CTRL_BATTERY_CHARGE_EN,FALSE);
#if _MIPS_TODO
if(!gIsUSBChargePreCheck
&& (GxSystem_GetState(SYSTEM_STATE_POWERON) != SYSTEM_POWERON_CHARGE)
)
{
#if (USB_CHARGE_VERIFY == ENABLE)
#else
GxLED_SetCtrl(KEYSCAN_LED_GREEN,SET_TOGGLE_LED,FALSE);
GxLED_SetCtrl(KEYSCAN_LED_GREEN,TURNON_LED,TRUE);
#endif
//GxLED_SetCtrl(KEYSCAN_LED_RED,SET_TOGGLE_LED,FALSE);
//GxLED_SetCtrl(KEYSCAN_LED_RED,TURNON_LED,FALSE);
}
#endif
DBG_DUMP("GxPower: Start low-battery check.\r\n");
GxPower_SetControl(GXPWR_CTRL_BATTERY_DETECT_EN, TRUE);
// enable flash re-charge
SxTimer_SetFuncActive(SX_TIMER_DET_RECHARGE_ID,TRUE);
//#NT#2010/12/10#Jeah Yen -end
}
/*
* pOpenFontTableFile - open the Font translation file
* Copy the file to the proper place if necessary.
*
* Returns the file pointer or NULL
*/
FILE *
pOpenFontTableFile(void)
{
FILE *pFileR, *pFileW;
char *szFontNamesFile;
size_t tSize;
BOOL bFailed;
char acBuffer[256];
pFileR = fopen("<AntiWord$FontNamesFile>", "r");
if (pFileR != NULL) {
/* The font table is already in the right directory */
return pFileR;
}
szFontNamesFile = getenv("AntiWord$FontNamesSave");
if (szFontNamesFile == NULL) {
werr(0, "Warning: Name of the FontNames file not found");
return NULL;
}
DBG_MSG(szFontNamesFile);
pFileR = fopen("<AntiWord$Dir>.Resources.Default", "r");
if (pFileR == NULL) {
werr(0, "I can't find 'Resources.Default'");
return NULL;
}
/* Here the default font translation table is known to exist */
if (!bMakeDirectory(szFontNamesFile)) {
werr(0,
"I can't make a directory for the FontNames file");
return NULL;
}
/* Here the proper directory is known to exist */
pFileW = fopen(szFontNamesFile, "w");
if (pFileW == NULL) {
(void)fclose(pFileR);
werr(0, "I can't create a default FontNames file");
return NULL;
}
/* Here the proper directory is known to be writeable */
/* Copy the default FontNames file */
bFailed = FALSE;
while (!feof(pFileR)) {
tSize = fread(acBuffer, 1, sizeof(acBuffer), pFileR);
if (ferror(pFileR)) {
DBG_MSG("Read error");
bFailed = TRUE;
break;
}
if (fwrite(acBuffer, 1, tSize, pFileW) != tSize) {
DBG_MSG("Write error");
bFailed = TRUE;
break;
}
}
(void)fclose(pFileW);
(void)fclose(pFileR);
if (bFailed) {
DBG_MSG("Copying the FontNames file failed");
(void)remove(szFontNamesFile);
return NULL;
}
return fopen(szFontNamesFile, "r");
} /* end of pOpenFontTableFile */
//------------------------------------------------------------------------------
//!
bool
BIH::trace( const Rayf& ray, Hit& hit, IntersectFunc intersect, void* data ) const
{
DBG_BLOCK( os_bih_trace, "BIH::trace(" << ray.origin() << ray.direction() << " hit: t=" << hit._t << " id=" << hit._id << ")" );
if( _nodes.empty() )
{
return false;
}
Vec3f invDir = ray.direction().getInversed();
// Compute traversal order.
uint order[3];
order[0] = invDir(0) >= 0.0f ? 0 : 1;
order[1] = invDir(1) >= 0.0f ? 0 : 1;
order[2] = invDir(2) >= 0.0f ? 0 : 1;
float tmin = 0.0f;
float tmax = hit._t;
bool impact = false;
// Traverse tree.
Vector<TraversalStackNode> stack( _maxDepth );
uint stackID = 0;
const Node* node = &_nodes[0];
while( 1 )
{
DBG_MSG( os_bih_trace, "Visiting " << *node );
if( node->isInteriorNode() )
{
uint axis = node->axis();
float tplane0 = ( node->_plane[order[axis]] - ray.origin()(axis)) * invDir(axis);
float tplane1 = ( node->_plane[1-order[axis]] - ray.origin()(axis)) * invDir(axis);
// Clip node.
if( node->isClipNode() )
{
// FIXME: we could probably do better (not traversing this node).
node = &_nodes[node->index()];
tmin = CGM::max( tmin, tplane0 );
tmax = CGM::min( tmax, tplane1 );
continue;
}
bool traverse0 = tmin < tplane0;
bool traverse1 = tmax > tplane1;
if( traverse0 )
{
if( traverse1 )
{
stack[stackID++].set(
&_nodes[node->index() + 1-order[axis]],
CGM::max( tmin, tplane1 ),
tmax
);
}
node = &_nodes[node->index() + order[axis]];
tmax = CGM::min( tmax, tplane0 );
}
else
{
if( traverse1 )
{
node = &_nodes[node->index() + 1-order[axis]];
tmin = CGM::max( tmin, tplane1 );
}
else
{
// Unstack.
do
{
if( stackID == 0 )
{
return impact;
}
stack[--stackID].get( node, tmin, tmax );
tmax = CGM::min( tmax, hit._t );
} while( tmin > tmax );
}
}
}
else
{
// We are in a leaf node.
// Intersects all primitives in it.
uint numElems = node->_numElements;
uint id = node->index();
for( uint i = 0; i < numElems; ++i, ++id )
{
if( intersect( ray, _ids[id], hit._t, data ) )
{
impact = true;
hit._id = _ids[id];
}
}
// Unstack.
do
{
if( stackID == 0 )
{
return impact;
}
stack[--stackID].get( node, tmin, tmax );
tmax = CGM::min( tmax, hit._t );
} while( tmin > tmax );
}
}
}
/*
* Translate the rowinfo to a member of the row_info enumeration
*/
row_info_enum
eGet8RowInfo(int iFodo,
const UCHAR *aucGrpprl, int iBytes, row_block_type *pRow)
{
int iFodoOff, iInfoLen;
int iIndex, iSize, iCol;
int iPosCurr, iPosPrev;
USHORT usTmp;
BOOL bFound2416_0, bFound2416_1, bFound2417_0, bFound2417_1;
BOOL bFound244b_0, bFound244b_1, bFound244c_0, bFound244c_1;
BOOL bFoundd608;
fail(iFodo < 0 || aucGrpprl == NULL || pRow == NULL);
iFodoOff = 0;
bFound2416_0 = FALSE;
bFound2416_1 = FALSE;
bFound2417_0 = FALSE;
bFound2417_1 = FALSE;
bFound244b_0 = FALSE;
bFound244b_1 = FALSE;
bFound244c_0 = FALSE;
bFound244c_1 = FALSE;
bFoundd608 = FALSE;
while (iBytes >= iFodoOff + 2) {
iInfoLen = 0;
switch (usGetWord(iFodo + iFodoOff, aucGrpprl)) {
case 0x2416: /* fInTable */
if (odd(ucGetByte(iFodo + iFodoOff + 2, aucGrpprl))) {
bFound2416_1 = TRUE;
} else {
bFound2416_0 = TRUE;
}
break;
case 0x2417: /* fTtp */
if (odd(ucGetByte(iFodo + iFodoOff + 2, aucGrpprl))) {
bFound2417_1 = TRUE;
} else {
bFound2417_0 = TRUE;
}
break;
case 0x244b: /* sub-table fInTable */
if (odd(ucGetByte(iFodo + iFodoOff + 2, aucGrpprl))) {
bFound244b_1 = TRUE;
} else {
bFound244b_0 = TRUE;
}
break;
case 0x244c: /* sub-table fTtp */
if (odd(ucGetByte(iFodo + iFodoOff + 2, aucGrpprl))) {
bFound244c_1 = TRUE;
} else {
bFound244c_0 = TRUE;
}
break;
case 0x6424: /* brcTop */
usTmp = usGetWord(iFodo + iFodoOff + 2, aucGrpprl);
usTmp &= 0xff00;
NO_DBG_DEC(usTmp >> 8);
if (usTmp == 0) {
pRow->ucBorderInfo &= ~TABLE_BORDER_TOP;
} else {
pRow->ucBorderInfo |= TABLE_BORDER_TOP;
}
break;
case 0x6425: /* brcLeft */
usTmp = usGetWord(iFodo + iFodoOff + 2, aucGrpprl);
usTmp &= 0xff00;
NO_DBG_DEC(usTmp >> 8);
if (usTmp == 0) {
pRow->ucBorderInfo &= ~TABLE_BORDER_LEFT;
} else {
pRow->ucBorderInfo |= TABLE_BORDER_LEFT;
}
break;
case 0x6426: /* brcBottom */
usTmp = usGetWord(iFodo + iFodoOff + 2, aucGrpprl);
usTmp &= 0xff00;
NO_DBG_DEC(usTmp >> 8);
if (usTmp == 0) {
pRow->ucBorderInfo &= ~TABLE_BORDER_BOTTOM;
} else {
pRow->ucBorderInfo |= TABLE_BORDER_BOTTOM;
}
break;
case 0x6427: /* brcRight */
usTmp = usGetWord(iFodo + iFodoOff + 2, aucGrpprl);
usTmp &= 0xff00;
NO_DBG_DEC(usTmp >> 8);
if (usTmp == 0) {
pRow->ucBorderInfo &= ~TABLE_BORDER_RIGHT;
} else {
pRow->ucBorderInfo |= TABLE_BORDER_RIGHT;
}
break;
case 0xd606: /* cDefTable10 */
DBG_MSG("0xd606: sprmTDefTable10");
iSize = (int)usGetWord(iFodo + iFodoOff + 2, aucGrpprl);
DBG_DEC(iSize);
break;
case 0xd608: /* cDefTable */
iSize = (int)usGetWord(iFodo + iFodoOff + 2, aucGrpprl);
if (iSize < 6 || iBytes < iFodoOff + 8) {
DBG_DEC(iSize);
DBG_DEC(iFodoOff);
iInfoLen = 2;
break;
}
iCol = (int)ucGetByte(iFodo + iFodoOff + 4, aucGrpprl);
if (iCol < 1 ||
iBytes < iFodoOff + 4 + (iCol + 1) * 2) {
DBG_DEC(iCol);
DBG_DEC(iFodoOff);
iInfoLen = 2;
break;
}
if (iCol >= (int)elementsof(pRow->asColumnWidth)) {
DBG_DEC(iCol);
werr(1, "The number of columns is corrupt");
}
pRow->ucNumberOfColumns = (UCHAR)iCol;
iPosPrev = (int)(short)usGetWord(
iFodo + iFodoOff + 5,
aucGrpprl);
for (iIndex = 0; iIndex < iCol; iIndex++) {
iPosCurr = (int)(short)usGetWord(
iFodo + iFodoOff + 7 + iIndex * 2,
aucGrpprl);
pRow->asColumnWidth[iIndex] =
(short)(iPosCurr - iPosPrev);
iPosPrev = iPosCurr;
}
bFoundd608 = TRUE;
break;
default:
break;
}
if (iInfoLen <= 0) {
iInfoLen =
iGet8InfoLength(iFodo + iFodoOff, aucGrpprl);
fail(iInfoLen <= 0);
}
iFodoOff += iInfoLen;
}
if (bFound2417_1 && bFoundd608) {
return found_end_of_row;
}
if (bFound2417_0 && !bFoundd608) {
return found_not_end_of_row;
}
if (bFound2416_1 || bFound244b_1) {
return found_a_cell;
}
if (bFound2416_0 || bFound244b_0) {
return found_not_a_cell;
}
return found_nothing;
} /* end of eGet8RowInfo */
void UIDisplay_Init(UINT8 iDD, BOOL bClear, ISIZE* pDeviceSize)
{
RESULT r;
LAYER_INIT LayerInit;
UINT32 uiBufAddr;
//fixed buffer size
UINT32 osd_w = OSD_W;
UINT32 osd_h = OSD_H;
//fixed buffer size
UINT32 vdo_w = OSD_W;
UINT32 vdo_h = OSD_H;
//ISIZE DeviceSize;
LAYER_INIT* pLayerInit = (LAYER_INIT*)&LayerInit; //layer init parameter
//DeviceSize = GxVideo_GetDeviceSize(DOUT1);
ISIZE DeviceSize = pDeviceSize[0];
DBG_MSG("DOUT=%d\n\r",iDD>>4);
switch(iDD & 0x0f) //check layer
{
case LAYER_OSD1:
uiBufAddr = OS_GetMempoolAddr(POOL_ID_DISP_OSD1);
pLayerInit->uiType = TYPE_FB;
pLayerInit->uiPxlfmt = DISPLAY_OSD_FMT;
pLayerInit->uiWidth = osd_w;
pLayerInit->uiHeight = osd_h;
#if (OSD_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->uiBufCount = 1;
pLayerInit->uiSwapEffect = SWAPEFFECT_COPY;
#else
pLayerInit->uiBufCount = 0;
pLayerInit->uiSwapEffect = SWAPEFFECT_DISCARD;
#endif
switch(pLayerInit->uiPxlfmt)
{
case PXLFMT_INDEX1:
pLayerInit->uiBufSize = (osd_w*osd_h)>>3;
break;
case PXLFMT_INDEX2:
pLayerInit->uiBufSize = (osd_w*osd_h)>>2;
break;
case PXLFMT_INDEX4:
pLayerInit->uiBufSize = (osd_w*osd_h)>>1;
break;
case PXLFMT_INDEX8:
pLayerInit->uiBufSize = (osd_w*osd_h)>>0;
break;
}
pLayerInit->pBufAddr[0] = uiBufAddr;
#if (OSD_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->pBufAddr[1] = uiBufAddr + pLayerInit->uiBufSize;
#else
pLayerInit->pBufAddr[1] = 0;
#endif
pLayerInit->pBufAddr[2] = 0;
//dynamic window size
pLayerInit->win.x= 0;
pLayerInit->win.y = 0;
pLayerInit->win.w = DeviceSize.w;
pLayerInit->win.h = DeviceSize.h;
pLayerInit->uiWinAttr = 0;
#if (OSD_USE_ROTATE_BUFFER == ENABLE)
if(gbOsdRotate == 1)
{
DBG_MSG("^YEnable Rotate\r\n");
//prepare show DC
UINT32 buf_w = pLayerInit->uiWidth;
UINT32 buf_h = pLayerInit->uiHeight;
UINT32 win_w = pLayerInit->win.w;
UINT32 win_h = pLayerInit->win.h;
pLayerInit->uiWidth = buf_h;
pLayerInit->uiHeight = buf_w;
pLayerInit->uiBufCount = 0;
pLayerInit->uiSwapEffect = SWAPEFFECT_DISCARD;
pLayerInit->pBufAddr[0] = uiBufAddr;
pLayerInit->pBufAddr[1] = 0;
pLayerInit->pBufAddr[2] = 0;
pLayerInit->win.w = win_h;
pLayerInit->win.h = win_w;
//prepare paint DC
memset(pPaintDC, 0, sizeof(DC));
GxGfx_AttachDC(pPaintDC, TYPE_FB,
pLayerInit->uiPxlfmt, buf_w, buf_h, buf_w,
(UINT8*)(uiBufAddr + pLayerInit->uiBufSize), 0, 0);
}
else
{
DBG_MSG("^YDisable Rotate\r\n");
}
#endif
r = GxDisplay_InitLayer(iDD, &LayerInit, bClear);
UI_DirtyDisplaySource(iDD); //must force flush to update new swap-buffer and new swap-effect
DBG_MSG("OSD1 buf=%08x, size=%08x\n\r",LayerInit.pBufAddr[0], LayerInit.uiBufSize);
DBG_MSG("OSD1 buf.w=%d, buf.h=%d;\n\r",LayerInit.uiWidth, LayerInit.uiHeight);
DBG_MSG("OSD1 win.w=%d, win.h=%d;\n\r",LayerInit.win.w, LayerInit.win.h);
break;
case LAYER_OSD2:
uiBufAddr = OS_GetMempoolAddr(POOL_ID_DISP_OSD2);
pLayerInit->uiType = TYPE_FB;
pLayerInit->uiPxlfmt = DISPLAY_OSD_FMT;
pLayerInit->uiWidth = osd_w;
pLayerInit->uiHeight = osd_h;
#if (OSD2_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->uiBufCount = 1;
pLayerInit->uiSwapEffect = SWAPEFFECT_COPY;
#else
pLayerInit->uiBufCount = 0;
pLayerInit->uiSwapEffect = SWAPEFFECT_DISCARD;
#endif
switch(pLayerInit->uiPxlfmt)
{
case PXLFMT_INDEX1:
pLayerInit->uiBufSize = (osd_w*osd_h)>>3;
break;
case PXLFMT_INDEX2:
pLayerInit->uiBufSize = (osd_w*osd_h)>>2;
break;
case PXLFMT_INDEX4:
pLayerInit->uiBufSize = (osd_w*osd_h)>>1;
break;
case PXLFMT_INDEX8:
pLayerInit->uiBufSize = (osd_w*osd_h)>>0;
break;
}
pLayerInit->pBufAddr[0] = uiBufAddr;
#if (OSD2_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->pBufAddr[1] = uiBufAddr + pLayerInit->uiBufSize;
#else
pLayerInit->pBufAddr[1] = 0;
#endif
pLayerInit->pBufAddr[2] = 0;
//dynamic window size
pLayerInit->win.x= 0;
pLayerInit->win.y = 0;
pLayerInit->win.w = DeviceSize.w;
pLayerInit->win.h = DeviceSize.h;
pLayerInit->uiWinAttr = 0;
r = GxDisplay_InitLayer(iDD, &LayerInit, bClear);
DBG_MSG("OSD2 buf=%08x, size=%08x\n\r",LayerInit.pBufAddr[0], LayerInit.uiBufSize);
DBG_MSG("OSD2 buf.w=%d, buf.h=%d;\n\r",LayerInit.uiWidth, LayerInit.uiHeight);
DBG_MSG("OSD2 win.w=%d, win.h=%d;\n\r",LayerInit.win.w, LayerInit.win.h);
break;
case LAYER_VDO1:
uiBufAddr = OS_GetMempoolAddr(POOL_ID_DISP_VDO1);
pLayerInit->uiType = TYPE_FB;
pLayerInit->uiPxlfmt = DISPLAY_VDO_FMT;
pLayerInit->uiWidth = vdo_w;
pLayerInit->uiHeight = vdo_h;
#if (VDO_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->uiBufCount = 1;
pLayerInit->uiSwapEffect = SWAPEFFECT_COPY;
#else
pLayerInit->uiBufCount = 0;
pLayerInit->uiSwapEffect = SWAPEFFECT_DISCARD;
#endif
switch(pLayerInit->uiPxlfmt)
{
case PXLFMT_YUV422:
case PXLFMT_YUV422_PK:
pLayerInit->uiBufSize = (vdo_w*vdo_h)*2 + 64;
break;
break;
default:
DBG_ERR("Pxlfmt %d",pLayerInit->uiPxlfmt);
}
pLayerInit->pBufAddr[0] = uiBufAddr;
#if (VDO_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->pBufAddr[1] = uiBufAddr + pLayerInit->uiBufSize;
#else
pLayerInit->pBufAddr[1] = 0;
#endif
pLayerInit->pBufAddr[2] = 0;
//dynamic window size
pLayerInit->win.x= 0;
pLayerInit->win.y = 0;
pLayerInit->win.w = DeviceSize.w;
pLayerInit->win.h = DeviceSize.h;
pLayerInit->uiWinAttr = 0;
r = GxDisplay_InitLayer(iDD, &LayerInit, bClear);
DBG_MSG("VDO1 buf=%08x, size=%08x\n\r",LayerInit.pBufAddr[0], LayerInit.uiBufSize);
DBG_MSG("VDO1 buf.w=%d, buf.h=%d;\n\r",LayerInit.uiWidth, LayerInit.uiHeight);
DBG_MSG("VDO1 win.w=%d, win.h=%d;\n\r",LayerInit.win.w, LayerInit.win.h);
break;
case LAYER_VDO2:
uiBufAddr = OS_GetMempoolAddr(POOL_ID_DISP_VDO2);
pLayerInit->uiType = TYPE_FB;
pLayerInit->uiPxlfmt = DISPLAY_VDO_FMT;
pLayerInit->uiWidth = vdo_w;
pLayerInit->uiHeight = vdo_h;
#if (VDO2_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->uiBufCount = 1;
pLayerInit->uiSwapEffect = SWAPEFFECT_COPY;
#else
pLayerInit->uiBufCount = 0;
pLayerInit->uiSwapEffect = SWAPEFFECT_DISCARD;
#endif
switch(pLayerInit->uiPxlfmt)
{
case PXLFMT_YUV422:
case PXLFMT_YUV422_PK:
pLayerInit->uiBufSize = (vdo_w*vdo_h)*2 + 64;
break;
default:
DBG_ERR("Pxlfmt %d",pLayerInit->uiPxlfmt);
}
pLayerInit->pBufAddr[0] = uiBufAddr;
#if (VDO2_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->pBufAddr[1] = uiBufAddr + pLayerInit->uiBufSize;
#else
pLayerInit->pBufAddr[1] = 0;
#endif
pLayerInit->pBufAddr[2] = 0;
pLayerInit->win.x = 0;
pLayerInit->win.y = 0;
pLayerInit->win.w = DeviceSize.w;
pLayerInit->win.h = DeviceSize.h;
pLayerInit->uiWinAttr = 0;
r = GxDisplay_InitLayer(iDD, &LayerInit, bClear);
DBG_MSG("VDO2 buf1=%08x, size=%08x\n\r",LayerInit.pBufAddr[0], LayerInit.uiBufSize);
DBG_MSG("VDO2 buf2=%08x, size=%08x\n\r",LayerInit.pBufAddr[1], LayerInit.uiBufSize);
DBG_MSG("VDO2 buf.w=%d, buf.h=%d;\n\r",LayerInit.uiWidth, LayerInit.uiHeight);
DBG_MSG("VDO2 win.w=%d, win.h=%d;\n\r",LayerInit.win.w, LayerInit.win.h);
break;
}
}
/*
* Build the list with List Information for Word 8/9/10/11 files
*/
void
vGet8LstInfo(FILE *pFile, const pps_info_type *pPPS,
const ULONG *aulBBD, size_t tBBDLen,
const ULONG *aulSBD, size_t tSBDLen,
const UCHAR *aucHeader)
{
list_block_type tList;
const ULONG *aulBlockDepot;
UCHAR *aucLfoInfo, *aucLstfInfo, *aucPapx, *aucXString;
ULONG ulBeginLfoInfo, ulBeginLstfInfo, ulBeginLvlfInfo;
ULONG ulListID, ulStart;
size_t tBlockDepotLen, tBlockSize;
size_t tLfoInfoLen, tLstfInfoLen, tPapxLen, tXstLen, tOff;
size_t tLstfRecords, tStart, tIndex;
int iNums;
USHORT usIstd;
UCHAR ucTmp, ucListLevel, ucMaxLevel, ucChpxLen;
UCHAR aucLvlfInfo[28], aucXst[2];
fail(pFile == NULL || pPPS == NULL || aucHeader == NULL);
fail(aulBBD == NULL || aulSBD == NULL);
NO_DBG_DEC(pPPS->tTable.ulSB);
NO_DBG_HEX(pPPS->tTable.ulSize);
if (pPPS->tTable.ulSize == 0) {
DBG_MSG("No list information");
return;
}
if (pPPS->tTable.ulSize < MIN_SIZE_FOR_BBD_USE) {
/* Use the Small Block Depot */
aulBlockDepot = aulSBD;
tBlockDepotLen = tSBDLen;
tBlockSize = SMALL_BLOCK_SIZE;
} else {
/* Use the Big Block Depot */
aulBlockDepot = aulBBD;
tBlockDepotLen = tBBDLen;
tBlockSize = BIG_BLOCK_SIZE;
}
/* LFO (List Format Override) */
ulBeginLfoInfo = ulGetLong(0x2ea, aucHeader); /* fcPlfLfo */
DBG_HEX(ulBeginLfoInfo);
tLfoInfoLen = (size_t)ulGetLong(0x2ee, aucHeader); /* lcbPlfLfo */
DBG_DEC(tLfoInfoLen);
if (tLfoInfoLen == 0) {
DBG_MSG("No lists in this document");
return;
}
aucLfoInfo = xmalloc(tLfoInfoLen);
if (!bReadBuffer(pFile, pPPS->tTable.ulSB,
aulBlockDepot, tBlockDepotLen, tBlockSize,
aucLfoInfo, ulBeginLfoInfo, tLfoInfoLen)) {
aucLfoInfo = xfree(aucLfoInfo);
return;
}
NO_DBG_PRINT_BLOCK(aucLfoInfo, tLfoInfoLen);
vBuildLfoList(aucLfoInfo, tLfoInfoLen);
aucLfoInfo = xfree(aucLfoInfo);
/* LSTF (LiST data on File) */
ulBeginLstfInfo = ulGetLong(0x2e2, aucHeader); /* fcPlcfLst */
DBG_HEX(ulBeginLstfInfo);
tLstfInfoLen = (size_t)ulGetLong(0x2e6, aucHeader); /* lcbPlcfLst */
DBG_DEC(tLstfInfoLen);
if (tLstfInfoLen == 0) {
DBG_MSG("No list data on file");
return;
}
aucLstfInfo = xmalloc(tLstfInfoLen);
if (!bReadBuffer(pFile, pPPS->tTable.ulSB,
aulBlockDepot, tBlockDepotLen, tBlockSize,
aucLstfInfo, ulBeginLstfInfo, tLstfInfoLen)) {
aucLstfInfo = xfree(aucLstfInfo);
return;
}
NO_DBG_PRINT_BLOCK(aucLstfInfo, tLstfInfoLen);
tLstfRecords = (size_t)usGetWord(0, aucLstfInfo);
if (2 + tLstfRecords * 28 < tLstfInfoLen) {
DBG_DEC(2 + tLstfRecords * 28);
DBG_DEC(tLstfInfoLen);
aucLstfInfo = xfree(aucLstfInfo);
return;
}
/* LVLF (List leVeL on File) */
ulBeginLvlfInfo = ulBeginLstfInfo + tLstfInfoLen;
DBG_HEX(ulBeginLvlfInfo);
aucXString = NULL;
ulStart = ulBeginLvlfInfo;
for (tIndex = 0, tStart = 2;
tIndex < tLstfRecords;
tIndex++, tStart += 28) {
ulListID = ulGetLong(tStart, aucLstfInfo);
NO_DBG_HEX(ulListID);
ucTmp = ucGetByte(tStart + 26, aucLstfInfo);
ucMaxLevel = odd(ucTmp) ? 1 : 9;
for (ucListLevel = 0; ucListLevel < ucMaxLevel; ucListLevel++) {
fail(aucXString != NULL);
usIstd = usGetWord(
tStart + 8 + 2 * (size_t)ucListLevel,
aucLstfInfo);
DBG_DEC_C(usIstd != STI_NIL, usIstd);
NO_DBG_HEX(ulStart);
(void)memset(&tList, 0, sizeof(tList));
/* Read the lvlf (List leVeL on File) */
if (!bReadBuffer(pFile, pPPS->tTable.ulSB,
aulBlockDepot, tBlockDepotLen,
tBlockSize, aucLvlfInfo,
ulStart, sizeof(aucLvlfInfo))) {
aucLstfInfo = xfree(aucLstfInfo);
return;
}
NO_DBG_PRINT_BLOCK(aucLvlfInfo, sizeof(aucLvlfInfo));
if (bAllZero(aucLvlfInfo, sizeof(aucLvlfInfo))) {
tList.ulStartAt = 1;
tList.ucNFC = 0x00;
tList.bNoRestart = FALSE;
} else {
tList.ulStartAt = ulGetLong(0, aucLvlfInfo);
tList.ucNFC = ucGetByte(4, aucLvlfInfo);
ucTmp = ucGetByte(5, aucLvlfInfo);
tList.bNoRestart = (ucTmp & BIT(3)) != 0;
DBG_MSG_C((ucTmp & BIT(4)) != 0 &&
(ucTmp & BIT(6)) != 0, "Found one");
}
ulStart += sizeof(aucLvlfInfo);
tPapxLen = (size_t)ucGetByte(25, aucLvlfInfo);
if (tPapxLen != 0) {
aucPapx = xmalloc(tPapxLen);
/* Read the Papx */
if (!bReadBuffer(pFile, pPPS->tTable.ulSB,
aulBlockDepot, tBlockDepotLen,
tBlockSize, aucPapx,
ulStart, tPapxLen)) {
aucPapx = xfree(aucPapx);
aucLstfInfo = xfree(aucLstfInfo);
return;
}
NO_DBG_PRINT_BLOCK(aucPapx, tPapxLen);
tList.sLeftIndent =
sGetLeftIndent(aucPapx, tPapxLen);
aucPapx = xfree(aucPapx);
}
ulStart += tPapxLen;
ucChpxLen = ucGetByte(24, aucLvlfInfo);
ulStart += (ULONG)ucChpxLen;
/* Read the length of the XString */
if (!bReadBuffer(pFile, pPPS->tTable.ulSB,
aulBlockDepot, tBlockDepotLen,
tBlockSize, aucXst,
ulStart, sizeof(aucXst))) {
aucLstfInfo = xfree(aucLstfInfo);
return;
}
NO_DBG_PRINT_BLOCK(aucXst, sizeof(aucXst));
tXstLen = (size_t)usGetWord(0, aucXst);
ulStart += sizeof(aucXst);
if (tXstLen == 0) {
tList.usListChar = DEFAULT_LISTCHAR;
vAdd2ListInfoList(ulListID,
usIstd,
ucListLevel,
&tList);
continue;
}
tXstLen *= 2; /* Length in chars to length in bytes */
aucXString = xmalloc(tXstLen);
/* Read the XString */
if (!bReadBuffer(pFile, pPPS->tTable.ulSB,
aulBlockDepot, tBlockDepotLen,
tBlockSize, aucXString,
ulStart, tXstLen)) {
aucXString = xfree(aucXString);
aucLstfInfo = xfree(aucLstfInfo);
return;
}
NO_DBG_PRINT_BLOCK(aucXString, tXstLen);
tOff = 0;
for (iNums = 6; iNums < 15; iNums++) {
ucTmp = ucGetByte(iNums, aucLvlfInfo);
if (ucTmp == 0) {
break;
}
tOff = (size_t)ucTmp;
}
tOff *= 2; /* Offset in chars to offset in bytes */
NO_DBG_DEC(tOff);
if (tList.ucNFC == LIST_SPECIAL ||
tList.ucNFC == LIST_SPECIAL2 ||
tList.ucNFC == LIST_BULLETS) {
tList.usListChar = usGetWord(0, aucXString);
} else if (tOff != 0 && tOff < tXstLen) {
tList.usListChar = usGetWord(tOff, aucXString);
} else {
tList.usListChar = DEFAULT_LISTCHAR;
}
vAdd2ListInfoList(ulListID,
usIstd,
ucListLevel,
&tList);
ulStart += tXstLen;
aucXString = xfree(aucXString);
}
}
aucLstfInfo = xfree(aucLstfInfo);
} /* end of vGet8LstInfo */
void System_OnStrgInit_FWS(void)
{
BOOL bLZC = FALSE;
ER er;
UINT32 m_LdLoadedOffest;
DX_HANDLE pStrgDev = 0;
DBG_MSG("Init!\r\n");
DBG_IND("^M LD_BLOCK=%d\r\n", gBinInfo.ld.LdBlockCount);
DBG_IND("^M FW_MAX_SIZE=%08X\r\n", gBinInfo.ld.FWResvSize);
DBG_IND("^MFW_validate-update:");
//ValidateUpdateFW
{
UINT32 bUpdate = ((gBinInfo.ld.LdCtrl2 & LDCF_UPDATE_FW)!=0);
UINT32 uiUpdateResult = ((gBinInfo.ld.LdCtrl2 & LDCF_UPDATE_FW_DONE)!=0);
if(bUpdate)
{
DBG_IND("\r\n^MFW is just updated.\r\n");
if(!uiUpdateResult)
{
DBG_FATAL("\r\nFW updated: fail!\r\n");
}
}
}
DBG_IND("^M ok\r\n");
pStrgDev = Dx_GetObject(DX_CLASS_STORAGE_EXT|DX_TYPE_NAND0);
#if (_INTERSTORAGE_==_INTERSTORAGE_SPI_)
bLZC = TRUE;
#else
bLZC = FALSE;
#endif
if(bLZC)
{
gPL_Init.PlInit.DataType = PARTLOAD_DATA_TYPE_COMPRESS_LZ;
gPL_BufAddr = OS_GetMempoolAddr(POOL_ID_APP);
gPL_BufSize = POOL_SIZE_APP;
}
else
{
gPL_Init.PlInit.DataType = PARTLOAD_DATA_TYPE_UNCOMPRESS;
gPL_BufAddr = OS_GetMempoolAddr(POOL_ID_FWS_BUFFER);
gPL_BufSize = POOL_SIZE_FWS_BUFFER;
}
m_LdLoadedOffest = gBinInfo.ld.LdLoadSize; //Get Ld loaded size
gPL_Init.uiApiVer = FWSRV_API_VERSION;
gPL_Init.TaskID = 0;
gPL_Init.SemID = 0;
gPL_Init.FlagID = 0;
gPL_Init.PlInit.uiApiVer = PARTLOAD_API_VERSION;
gPL_Init.PlInit.hStrg = pStrgDev;
gPL_Init.PlInit.uiAddrBegin = OS_GetMemAddr(MEM_CODE)+m_LdLoadedOffest; //Must be block boundary align
gPL_Init.PlInit.uiWorkingAddr = gPL_BufAddr;
gPL_Init.PlInit.uiWorkingSize = gPL_BufSize;
er = FwSrv_Init(&gPL_Init);
if(er != FWSRV_ER_OK)
{
DBG_ERR("Init failed!\r\n");
}
er = FwSrv_Open();
if(er != FWSRV_ER_OK)
{
DBG_ERR("Open failed!\r\n");
}
}
vpp_timing_t *vout_find_video_mode(int no,vout_info_t *info)
{
vout_t *vo;
char *edid = 0;
unsigned int vo_option;
vpp_timing_t *p_timing = 0;
unsigned int opt = 0;
int index = 0;
vpp_timing_t *edid_timing = 0;
if( (vo = vout_get_entry(no)) == 0 )
return 0;
// if( vo->num != VPP_VOUT_NUM_HDMI ) // wm3445 simulate dual display
{
if( info->fixed_timing ){
p_timing = info->fixed_timing;
DBG_MSG("%d(fixed timer)\n",no);
goto find_video_mode;
}
}
vo_option = vo->option[1];
DBG_MSG("(%d,%dx%d@%d,%d),%s\n",no,info->resx,info->resy,info->pixclk,info->fps,(vo_option & VOUT_OPT_INTERLACE)?"i":"p");
if( vo->status & VPP_VOUT_STS_PLUGIN ){
if( (edid = vout_get_edid(no)) ){
if( edid_parse(edid,&vo->edid_info) == 0 ){
edid = 0;
}
else {
opt = info->fps | ((vo_option & VOUT_OPT_INTERLACE)? EDID_TMR_INTERLACE:0);
if( edid_find_support(&vo->edid_info,info->resx,info->resy,opt,&edid_timing) ){
if( edid_timing ){
p_timing = edid_timing;
DBG_MSG("Use EDID detail timing\n");
goto find_video_mode;
}
}
}
}
}
do {
p_timing = vpp_get_video_mode(info->resx,info->resy,info->pixclk,&index);
DBG_MSG("find(%dx%d@%d) -> %dx%d\n",info->resx,info->resy,info->pixclk,p_timing->hpixel,p_timing->vpixel);
info->resx = p_timing->hpixel;
info->resy = p_timing->vpixel;
if( p_timing->option & VPP_OPT_INTERLACE ){
info->resy *= 2;
}
info->fps = VPP_GET_OPT_FPS(p_timing->option);
opt = info->fps | ((vo_option & VOUT_OPT_INTERLACE)? EDID_TMR_INTERLACE:0);
if( edid == 0 )
break;
DBG_MSG("find edid %dx%d@%d%s\n",info->resx,info->resy,info->fps,(opt & EDID_TMR_INTERLACE)?"i":"p");
if( edid_find_support(&vo->edid_info,info->resx,info->resy,opt,&edid_timing) ){
break;
}
opt = info->fps | ((vo_option & VOUT_OPT_INTERLACE)? 0:EDID_TMR_INTERLACE);
DBG_MSG("find edid %dx%d@%d%s\n",info->resx,info->resy,info->fps,(opt & EDID_TMR_INTERLACE)?"i":"p");
if( edid_find_support(&vo->edid_info,info->resx,info->resy,opt,&edid_timing) ){
break;
}
if( (info->resx <= vpp_video_mode_table[0].hpixel) || (index <=1) ){
info->resx = vpp_video_mode_table[0].hpixel;
info->resy = vpp_video_mode_table[0].vpixel;
break;
}
do {
index--;
p_timing = (vpp_timing_t *) &vpp_video_mode_table[index];
if( info->resx == p_timing->hpixel ){
int vpixel;
vpixel = p_timing->vpixel;
if( p_timing->option & VPP_OPT_INTERLACE ){
vpixel *= 2;
index--;
}
if( info->resy == vpixel ){
continue;
}
}
break;
} while(1);
info->resx = vpp_video_mode_table[index].hpixel;
info->resy = vpp_video_mode_table[index].vpixel;
if(vpp_video_mode_table[index].option & VPP_OPT_INTERLACE){
info->resy *= 2;
}
} while(1);
if( edid_timing ){
p_timing = edid_timing;
DBG_MSG("Use EDID detail timing\n");
}
else {
if( opt & EDID_TMR_INTERLACE )
vo_option |= VOUT_OPT_INTERLACE;
else
vo_option &= ~VOUT_OPT_INTERLACE;
p_timing = vpp_get_video_mode_ext(info->resx,info->resy,info->fps,vo_option);
}
find_video_mode:
{
int hpixel,vpixel;
info->resx = p_timing->hpixel;
info->resy = p_timing->vpixel;
hpixel = p_timing->hpixel + p_timing->hsync + p_timing->hfp + p_timing->hbp;
vpixel = p_timing->vpixel + p_timing->vsync + p_timing->vfp + p_timing->vbp;
if( p_timing->option & VPP_OPT_INTERLACE ) {
info->resy *= 2;
// vpixel *= 2;
}
info->pixclk = p_timing->pixel_clock;
info->fps = info->pixclk / (hpixel * vpixel);
info->resx_virtual = vpp_calc_fb_width(g_vpp.mb_colfmt,info->resx);
info->resy_virtual = info->resy;
}
DBG_MSG("Leave (%dx%d@%d,%d)\n",p_timing->hpixel,p_timing->vpixel,p_timing->pixel_clock,info->fps);
return p_timing;
}
void System_OnStrg_DownloadFW(UINT32* SecOrderTable, void (*LoadCallback)(const UINT32 Idx))
{
BOOL bEnablePartload = FALSE;
int nSect = 0;
DBG_MSG("Init!\r\n");
DBG_DUMP("^G[LOAD-FW]\r\n");
nSect = OS_GetMemSectionCount(MEM_CODE); //How to get last section ZI
DBG_DUMP("^GTotal Sections = %d\r\n", nSect);
if(LoadCallback)
LoadCallback(CODE_SECTION_01);
DBG_IND("^M P1_LOAD_SIZE=%08X, TIME=%d\r\n", gBinInfo.ld.LdLoadSize, gBinInfo.ld.LdLoadTime);
DBG_IND("^MPL_check_Ld:\r\n");
DBG_IND("^M PL_EN=%08X\r\n", gBinInfo.ld.LdCtrl & LDCF_PARTLOAD_EN);
DBG_IND("^M LZ_EN=%08X\r\n", gBinInfo.head.BinCtrl & HDCF_LZCOMPRESS_EN);
bEnablePartload = ((gBinInfo.ld.LdCtrl & LDCF_PARTLOAD_EN)!=0);
if(!bEnablePartload)
return;
DBG_IND("^MPL_validate-p1-range:");
//ValidatePartOne
{
// Make Sure: Partloader start (PART-2 start) <= Loader loaded end
int i;
UINT32 FwSize = 0;
UINT32 uiDestAddress = OS_GetMemAddr(MEM_CODE)+gBinInfo.ld.LdLoadSize;
if((uiDestAddress != 0) && (uiDestAddress < OS_GetMemAddr(1)))
{
DBG_FATAL("PART_TWO start (%08x) > PART_ONE loaded end (%08x)!\r\n",
OS_GetMemAddr(1), uiDestAddress );
}
// Make Sure: Partloader end (PART-last end) <= MEM_CODE end
for(i=0;i<nSect;i++)
{
DBG_IND("Sect%d: Addr:%08X, Size:%08X\r\n",i,OS_GetMemAddr(i),OS_GetMemSize(i));
FwSize += OS_GetMemSize(i);
}
if (OS_GetMemAddr(0)+FwSize > OS_GetMemAddr(MEM_CODE)+OS_GetMemSize(MEM_CODE))
{
DBG_FATAL("PART_LAST end (%08x) > MEM_CODE end (%08x)!\r\n",
OS_GetMemAddr(0)+FwSize, OS_GetMemAddr(MEM_CODE)+OS_GetMemSize(MEM_CODE));
}
}
DBG_IND("^M ok\r\n");
DBG_DUMP("^MPL_begin\r\n");
{
ER er;
gPL_In.puiIdxSequence = SecOrderTable;
gPL_In.fpLoadedCb = LoadCallback;
gPL_Cmd.Idx = FWSRV_CMD_IDX_PL_LOAD_BURST; //continue load
gPL_Cmd.In.pData = &gPL_In;
gPL_Cmd.In.uiNumByte = sizeof(gPL_In);
gPL_Cmd.Prop.bExitCmdFinish = TRUE;
er = FwSrv_Cmd(&gPL_Cmd);
if(er != FWSRV_ER_OK)
{
DBG_ERR("Process failed!\r\n");
}
}
DBG_DUMP("^MPL_end\r\n");
}
/* This is a copy of _ump_osk_msync from drivers/amlogic/gpu/ump/linux/ump_osk_low_level_mem.c
* with adapted parameters */
static void meson_drm_ump_osk_msync(struct drm_gem_cma_object *cma_obj, void *virt, u32 offset, size_t size, enum drm_meson_msync_op op, struct meson_drm_session_data *session_data)
{
struct drm_gem_object *gem_obj;
u32 start_p, end_p;
/* Flush L1 using virtual address, the entire range in one go.
* Only flush if user space process has a valid write mapping on given address. */
if ((cma_obj) && (virt != NULL) && (access_ok(VERIFY_WRITE, virt, size))) {
__cpuc_flush_dcache_area(virt, size);
DBG_MSG(3, ("meson_drm_ump_osk_msync(): Flushing CPU L1 Cache. CPU address: %x, size: %x\n", virt, size));
} else {
if (session_data) {
if (op == DRM_MESON_MSYNC_FLUSH_L1) {
DBG_MSG(4, ("meson_drm_ump_osk_msync(): Pending %d L1 cache flushes\n", session_data->has_pending_level1_cache_flush));
session_data->has_pending_level1_cache_flush = 0;
level1_cache_flush_all();
return;
} else {
if (session_data->cache_operations_ongoing) { /* This is set in cache_operations_control(start) */
session_data->has_pending_level1_cache_flush++;
DBG_MSG(4, ("meson_drm_ump_osk_msync(): Defering L1 cache flush (%d pending)\n" session_data->has_pending_level1_cache_flush));
} else {
/* Flushing the L1 cache for each switch_user() if ump_cache_operations_control(START) is not called */
level1_cache_flush_all();
}
}
} else {
DBG_MSG(4, ("Unkown state %s %d\n", __FUNCTION__, __LINE__));
level1_cache_flush_all();
}
}
if (!cma_obj)
return;
gem_obj = &cma_obj->base;
DBG_MSG(3, ("meson_drm_ump_osk_msync(): Flushing CPU L2 Cache\n"));
/* Flush L2 using physical addresses
* Our allocations are always contiguous (GEM CMA), so we have only one mem block */
if (offset >= gem_obj->size) {
offset -= gem_obj->size;
return;
}
if (offset) {
start_p = (u32)cma_obj->paddr + offset;
/* We'll zero the offset later, after using it to calculate end_p. */
} else {
start_p = (u32)cma_obj->paddr;
}
if (size < gem_obj->size - offset) {
end_p = start_p + size;
size = 0;
} else {
if (offset) {
end_p = start_p + (gem_obj->size - offset);
size -= gem_obj->size - offset;
offset = 0;
} else {
end_p = start_p + gem_obj->size;
size -= gem_obj->size;
}
}
switch (op) {
case DRM_MESON_MSYNC_CLEAN:
outer_clean_range(start_p, end_p);
break;
case DRM_MESON_MSYNC_CLEAN_AND_INVALIDATE:
outer_flush_range(start_p, end_p);
break;
case DRM_MESON_MSYNC_INVALIDATE:
outer_inv_range(start_p, end_p);
break;
default:
break;
}
return;
}
static int block_allocator_allocate(void* ctx, ump_dd_mem * mem)
{
block_allocator * allocator;
u32 left;
block_info * last_allocated = NULL;
int i = 0;
BUG_ON(!ctx);
BUG_ON(!mem);
allocator = (block_allocator*)ctx;
left = mem->size_bytes;
BUG_ON(!left);
BUG_ON(!&allocator->mutex);
mem->nr_blocks = ((left + UMP_BLOCK_SIZE - 1) & ~(UMP_BLOCK_SIZE - 1)) / UMP_BLOCK_SIZE;
mem->block_array = (ump_dd_physical_block*)vmalloc(sizeof(ump_dd_physical_block) * mem->nr_blocks);
if (NULL == mem->block_array) {
MSG_ERR(("Failed to allocate block array\n"));
return 0;
}
if (down_interruptible(&allocator->mutex)) {
MSG_ERR(("Could not get mutex to do block_allocate\n"));
return 0;
}
mem->size_bytes = 0;
while ((left > 0) && (allocator->first_free)) {
block_info * block;
block = allocator->first_free;
allocator->first_free = allocator->first_free->next;
block->next = last_allocated;
last_allocated = block;
allocator->num_free--;
mem->block_array[i].addr = get_phys(allocator, block);
mem->block_array[i].size = UMP_BLOCK_SIZE;
mem->size_bytes += UMP_BLOCK_SIZE;
i++;
if (left < UMP_BLOCK_SIZE) left = 0;
else left -= UMP_BLOCK_SIZE;
}
if (left) {
block_info * block;
/* release all memory back to the pool */
while (last_allocated) {
block = last_allocated->next;
last_allocated->next = allocator->first_free;
allocator->first_free = last_allocated;
last_allocated = block;
allocator->num_free++;
}
vfree(mem->block_array);
mem->backend_info = NULL;
mem->block_array = NULL;
DBG_MSG(4, ("Could not find a mem-block for the allocation.\n"));
up(&allocator->mutex);
return 0;
}
mem->backend_info = last_allocated;
up(&allocator->mutex);
mem->is_cached=0;
return 1;
}
void CPAL_I2C_ERR_UserCallback(CPAL_DevTypeDef pDevInstance, uint32_t Device_Error)
{
DBG_MSG("Error: %d", Device_Error);
}
void ICACHE_FLASH_ATTR config_set(serverConnData *conn, uint8_t argc, char *argv[]){
bool err = false;
cJSON * config = NULL;
cJSON * lastchild = NULL;
char *stmp = NULL;
DBG_MSG("config_set argc: %d\r\n", argc);
if (argc == 0)
espbuffsentprintf(conn, "Usage: set <key> [value]\r\nUse help for more details\r\n");
else if (argc == 1) {
// Delete config
DBG_MSG("Delete config %s\r\n", argv[1]);
config = get_parent_by_key(jconfig_root, argv[1], &stmp);
if (config != NULL) lastchild = cJSON_GetObjectItem(config, stmp);
DBG_MSG("config: %p, stmp: %p\r\n", config, stmp);
if (config == NULL) {
espbuffsentprintf(conn, "Could not found parent config with key [%s].\r\n", argv[1]);
}else if(lastchild == NULL) {
espbuffsentprintf(conn, "Could not found lastchild config with key [%s].\r\n", argv[1]);
} else {
char *tmp;
DBG_MSG("Delete %s from %s.\r\n", lastchild->string, config->string);
cJSON_DeleteItemFromObject(config, lastchild->string);
tmp = cJSON_PrintUnformatted(config);
espbuffsentstring(conn, "Deleted. Now content is:\r\n");
espbuffsentstring(conn, tmp);
os_free(tmp);
}
} else {
// Update config value
char value[255];
uint8_t i;
uint32_t idx = 0;
os_bzero(value, sizeof(value));
for (i=2; i<=argc; ++i) {
DBG_MSG("argv[%d] = %s.\r\n", i, argv[i]);
os_sprintf(value + idx, "%s ", argv[i]);
idx += os_strlen(argv[i]) + 1;
}
value[idx - 1] = 0;
DBG_MSG("Update config %s to %s.\r\n", argv[1], value);
config = get_parent_by_key(jconfig_root, argv[1], &stmp);
DBG_MSG("config: %p, stmp: %p\r\n", config, stmp);
if (config == NULL) {
espbuffsentprintf(conn, "Could not found parent config with key [%s].\r\n", argv[1]);
}else if (stmp == NULL) {
espbuffsentprintf(conn, "Could not found last config with key [%s].\r\n", argv[1]);
} else {
char *tmp;
int i;
cJSON *newchild = NULL;
DBG_MSG("stmp: %s, valuetype: %c.\r\n", stmp, value[0]);
lastchild = cJSON_GetObjectItem(config, stmp);
DBG_MSG("lastchild: %p.\r\n", lastchild);
switch (value[0]) {
case 'i':
if (os_strlen(value) < 2) {
espbuffsentstring(conn, "value is invalid format: i10\r\n");
break;
}
i = atoi(&value[1]);
newchild = cJSON_CreateNumber(i);
break;
case 's':
if (os_strlen(value) < 2) {
espbuffsentstring(conn, "value is invalid format: slamp\r\n");
break;
}
newchild = cJSON_CreateString(&value[1]);
DBG_MSG("Create item: %s -> %p.\r\n", &value[1], newchild);
break;
default:
espbuffsentstring(conn, "value is invalid format\r\n");
newchild = NULL;
break;
}
if (newchild != NULL) {
if (lastchild != NULL) {
cJSON_ReplaceItemInObject(config, lastchild->string, newchild);
} else {
DBG_MSG("Add config %s to %s.\r\n", stmp, config->string);
cJSON_AddItemToObject(config, stmp, newchild);
}
tmp = cJSON_PrintUnformatted(config);
espbuffsentstring(conn, "Updated. Now content is:\r\n");
espbuffsentstring(conn, tmp);
os_free(tmp);
}
}
}
if (err)
espbuffsentstring(conn, MSG_ERROR);
else
espbuffsentstring(conn, MSG_OK);
}
/*
* Build the list with footnote text information for Word 6/7 files
*/
static void
vGet6FootnotesText(FILE *pFile, ULONG ulStartBlock,
const ULONG *aulBBD, size_t tBBDLen,
const UCHAR *aucHeader)
{
footnote_local_type *pCurr;
UCHAR *aucBuffer;
ULONG ulCharPos, ulBeginOfFootnotes, ulOffset, ulBeginFootnoteText;
size_t tFootnoteTextLen;
size_t tIndex;
TRACE_MSG("vGet6FootnotesText");
fail(pFile == NULL || aucHeader == NULL);
fail(ulStartBlock > MAX_BLOCKNUMBER && ulStartBlock != END_OF_CHAIN);
fail(aulBBD == NULL);
ulBeginOfFootnotes = ulGetLong(0x18, aucHeader); /* fcMin */
ulBeginOfFootnotes += ulGetLong(0x34, aucHeader); /* ccpText */
NO_DBG_HEX(ulBeginOfFootnotes);
ulBeginFootnoteText = ulGetLong(0x70, aucHeader); /* fcPlcffndTxt */
NO_DBG_HEX(ulBeginFootnoteText);
tFootnoteTextLen =
(size_t)ulGetLong(0x74, aucHeader); /* lcbPlcffndTxt */
NO_DBG_DEC(tFootnoteTextLen);
if (tFootnoteTextLen < 12) {
DBG_MSG("No Footnote text in this document");
return;
}
aucBuffer = xmalloc(tFootnoteTextLen);
if (!bReadBuffer(pFile, ulStartBlock,
aulBBD, tBBDLen, BIG_BLOCK_SIZE,
aucBuffer, ulBeginFootnoteText, tFootnoteTextLen)) {
aucBuffer = xfree(aucBuffer);
return;
}
NO_DBG_PRINT_BLOCK(aucBuffer, tFootnoteTextLen);
fail(tFootnoteTextLength != 0);
tFootnoteTextLength = tFootnoteTextLen / 4 - 2;
fail(tFootnoteTextLength == 0);
fail(pFootnoteText != NULL);
pFootnoteText = xcalloc(tFootnoteTextLength,
sizeof(footnote_local_type));
for (tIndex = 0; tIndex < tFootnoteTextLength; tIndex++) {
pCurr = pFootnoteText + tIndex;
pCurr->tInfo.szText = NULL;
ulOffset = ulGetLong(tIndex * 4, aucBuffer);
NO_DBG_HEX(ulOffset);
ulCharPos = ulBeginOfFootnotes + ulOffset;
NO_DBG_HEX(ulCharPos);
NO_DBG_HEX(ulCharPos2FileOffset(ulCharPos));
pCurr->ulCharPosStart = ulCharPos;
ulOffset = ulGetLong(tIndex * 4 + 4, aucBuffer);
NO_DBG_HEX(ulOffset);
ulCharPos = ulBeginOfFootnotes + ulOffset;
NO_DBG_HEX(ulCharPos);
NO_DBG_HEX(ulCharPos2FileOffset(ulCharPos));
pCurr->ulCharPosNext = ulCharPos;
pCurr->bUseful = pCurr->ulCharPosStart != pCurr->ulCharPosNext;
}
aucBuffer = xfree(aucBuffer);
} /* end of vGet6FootnotesText */
void ICACHE_FLASH_ATTR ota_upgrade(serverConnData *conn, uint8_t argc, char *argv[]) {
espbuffsentprintf(conn, "START OTA UPGRADE...CUR ROM: %d.\r\n", ROMNUM);
if (argc == 0)
espbuffsentstring(conn, "OTA <SRV IP> <PORT> <FOLDER PATH>\r\n");
else if (argc != 3)
espbuffsentstring(conn, MSG_ERROR);
else {
uint16_t port = atoi(argv[2]);
uint8_t iparr[4];
uint8_t i;
char tmp[4];
char* pCurIp = argv[1];
char * ch;
DBG_MSG("OTA UPGRADE with IP:%s, port:%d, path:%s.\r\n", argv[1], argv[2], argv[3]);
for (i=0; i<protocol_idx; ++i) {
DBG_MSG("protocol_disconnect res: %d, index: %d\r\n", protocol_disconnect(&protocol_list[i]), i);
}
ch = strchr(pCurIp, '.');
DBG_MSG("First: %s\r\n", pCurIp);
DBG_MSG("After: %s\r\n", ch);
for (i = 0; i < 4; ++i) {
if (i < (ch - pCurIp + 1)) {
tmp[i] = pCurIp[i];
} else {
tmp[i] = 0;
}
}
iparr[0] = atoi(tmp);
pCurIp = ch + 1;
ch = strchr(pCurIp, '.');
DBG_MSG("First: %s\r\n", pCurIp);
DBG_MSG("After: %s\r\n", ch);
for (i = 0; i < 4; ++i) {
if (i < (ch - pCurIp + 1)) {
tmp[i] = pCurIp[i];
} else {
tmp[i] = 0;
}
}
iparr[1] = atoi(tmp);
pCurIp = ch + 1;
ch = strchr(pCurIp, '.');
DBG_MSG("First: %s\r\n", pCurIp);
DBG_MSG("After: %s\r\n", ch);
for (i = 0; i < 4; ++i) {
if (i < (ch - pCurIp + 1)) {
tmp[i] = pCurIp[i];
} else {
tmp[i] = 0;
}
}
iparr[2] = atoi(tmp);
pCurIp = ch + 1;
ch = strchr(pCurIp, '.');
DBG_MSG("First: %s\r\n", pCurIp);
DBG_MSG("After: %s\r\n", ch);
for (i = 0; i < 4; ++i) {
if (i < (argv[1] + strlen(argv[1]) - pCurIp + 1)) {
tmp[i] = pCurIp[i];
} else {
tmp[i] = 0;
}
}
iparr[3] = atoi(tmp);
DBG_MSG("=> IP: %d %d %d %d\r\n", iparr[0], iparr[1], iparr[2], iparr[3]);
if ((port == 0)||(port>65535)) {
espbuffsentstring(conn, MSG_ERROR);
} else {
espbuffsentstring(conn, MSG_OK);
handleUpgrade(2, iparr, port, argv[3]);
}
}
}
/*
* Build the list with footnote information for Word for DOS files
*/
static void
vGet0FootnotesInfoAndText(FILE *pFile, const UCHAR *aucHeader)
{
footnote_local_type *pCurr;
UCHAR *aucBuffer;
ULONG ulFileOffset, ulBeginOfText, ulOffset, ulBeginFootnoteInfo;
ULONG ulCharPos, ulBeginNextBlock;
size_t tFootnotes, tFootnoteInfoLen;
size_t tIndex;
UCHAR aucTmp[2];
TRACE_MSG("vGet0FootnotesInfoAndText");
fail(pFile == NULL || aucHeader == NULL);
ulBeginOfText = 128;
NO_DBG_HEX(ulBeginOfText);
ulBeginFootnoteInfo = 128 * (ULONG)usGetWord(0x14, aucHeader);
DBG_HEX(ulBeginFootnoteInfo);
ulBeginNextBlock = 128 * (ULONG)usGetWord(0x16, aucHeader);
DBG_HEX(ulBeginNextBlock);
if (ulBeginFootnoteInfo == ulBeginNextBlock) {
DBG_MSG("No Footnotes in this document");
return;
}
/* Read the the number of footnotes + 1 */
if (!bReadBytes(aucTmp, 2, ulBeginFootnoteInfo, pFile)) {
return;
}
tFootnotes = (size_t)usGetWord(0, aucTmp);
if (tFootnotes < 2) {
DBG_MSG("No Footnotes in this document (2)");
}
DBG_DEC(tFootnotes);
tFootnoteInfoLen = 8 * tFootnotes;
aucBuffer = xmalloc(tFootnoteInfoLen);
if (!bReadBytes(aucBuffer,
tFootnoteInfoLen, ulBeginFootnoteInfo + 4, pFile)) {
aucBuffer = xfree(aucBuffer);
return;
}
DBG_PRINT_BLOCK(aucBuffer, tFootnoteInfoLen);
/* Get footnote information */
fail(tFootnoteListLength != 0);
tFootnoteListLength = tFootnotes - 1;
fail(tFootnoteListLength == 0);
fail(aulFootnoteList != NULL);
aulFootnoteList = xcalloc(tFootnoteListLength, sizeof(ULONG));
for (tIndex = 0; tIndex < tFootnoteListLength; tIndex++) {
ulOffset = ulGetLong(tIndex * 8, aucBuffer);
DBG_HEX(ulOffset);
ulFileOffset = ulCharPos2FileOffset(ulBeginOfText + ulOffset);
DBG_HEX(ulFileOffset);
aulFootnoteList[tIndex] = ulFileOffset;
}
/* Get footnote text */
fail(tFootnoteTextLength != 0);
tFootnoteTextLength = tFootnotes - 1;
fail(tFootnoteTextLength == 0);
fail(pFootnoteText != NULL);
pFootnoteText = xcalloc(tFootnoteTextLength,
sizeof(footnote_local_type));
for (tIndex = 0; tIndex < tFootnoteTextLength; tIndex++) {
pCurr = pFootnoteText + tIndex;
pCurr->tInfo.szText = NULL;
ulOffset = ulGetLong(tIndex * 8 + 4, aucBuffer);
DBG_HEX(ulOffset);
ulCharPos = ulBeginOfText + ulOffset;
DBG_HEX(ulCharPos);
DBG_HEX(ulCharPos2FileOffset(ulCharPos));
pCurr->ulCharPosStart = ulCharPos;
ulOffset = ulGetLong((tIndex + 1) * 8 + 4, aucBuffer);
DBG_HEX(ulOffset);
ulCharPos = ulBeginOfText + ulOffset;
DBG_HEX(ulCharPos);
DBG_HEX(ulCharPos2FileOffset(ulCharPos));
pCurr->ulCharPosNext = ulCharPos;
pCurr->bUseful = pCurr->ulCharPosStart != pCurr->ulCharPosNext;
}
aucBuffer = xfree(aucBuffer);
} /* end of vGet0FootnotesInfoAndText */
/*
* Fill the font information block with information
* from a Word 8/9/10/11 file.
*/
void
vGet8FontInfo(int iFodo, USHORT usIstd,
const UCHAR *aucGrpprl, int iBytes, font_block_type *pFont)
{
long lTmp;
int iFodoOff, iInfoLen;
USHORT usFtc0, usFtc1, usFtc2, usTmp;
UCHAR ucTmp;
fail(iFodo < 0 || aucGrpprl == NULL || pFont == NULL);
usFtc0 = USHRT_MAX;
usFtc1 = USHRT_MAX;
usFtc2 = USHRT_MAX;
iFodoOff = 0;
while (iBytes >= iFodoOff + 2) {
switch (usGetWord(iFodo + iFodoOff, aucGrpprl)) {
case 0x0800: /* fRMarkDel */
ucTmp = ucGetByte(iFodo + iFodoOff + 2, aucGrpprl);
if (ucTmp == 0) {
pFont->usFontStyle &= ~FONT_MARKDEL;
} else {
pFont->usFontStyle |= FONT_MARKDEL;
}
break;
case 0x0835: /* fBold */
ucTmp = ucGetByte(iFodo + iFodoOff + 2, aucGrpprl);
switch (ucTmp) {
case 0: /* Unset */
pFont->usFontStyle &= ~FONT_BOLD;
break;
case 1: /* Set */
pFont->usFontStyle |= FONT_BOLD;
break;
case 128: /* Unchanged */
break;
case 129: /* Negation */
pFont->usFontStyle ^= FONT_BOLD;
break;
default:
DBG_DEC(ucTmp);
DBG_FIXME();
break;
}
break;
case 0x0836: /* fItalic */
ucTmp = ucGetByte(iFodo + iFodoOff + 2, aucGrpprl);
switch (ucTmp) {
case 0: /* Unset */
pFont->usFontStyle &= ~FONT_ITALIC;
break;
case 1: /* Set */
pFont->usFontStyle |= FONT_ITALIC;
break;
case 128: /* Unchanged */
break;
case 129: /* Negation */
pFont->usFontStyle ^= FONT_ITALIC;
break;
default:
DBG_DEC(ucTmp);
DBG_FIXME();
break;
}
break;
case 0x0837: /* fStrike */
ucTmp = ucGetByte(iFodo + iFodoOff + 2, aucGrpprl);
switch (ucTmp) {
case 0: /* Unset */
pFont->usFontStyle &= ~FONT_STRIKE;
break;
case 1: /* Set */
pFont->usFontStyle |= FONT_STRIKE;
break;
case 128: /* Unchanged */
break;
case 129: /* Negation */
pFont->usFontStyle ^= FONT_STRIKE;
break;
default:
DBG_DEC(ucTmp);
DBG_FIXME();
break;
}
break;
case 0x083a: /* fSmallCaps */
ucTmp = ucGetByte(iFodo + iFodoOff + 2, aucGrpprl);
switch (ucTmp) {
case 0: /* Unset */
pFont->usFontStyle &= ~FONT_SMALL_CAPITALS;
break;
case 1: /* Set */
pFont->usFontStyle |= FONT_SMALL_CAPITALS;
break;
case 128: /* Unchanged */
break;
case 129: /* Negation */
pFont->usFontStyle ^= FONT_SMALL_CAPITALS;
break;
default:
DBG_DEC(ucTmp);
DBG_FIXME();
break;
}
break;
case 0x083b: /* fCaps */
ucTmp = ucGetByte(iFodo + iFodoOff + 2, aucGrpprl);
switch (ucTmp) {
case 0: /* Unset */
pFont->usFontStyle &= ~FONT_CAPITALS;
break;
case 1: /* Set */
pFont->usFontStyle |= FONT_CAPITALS;
break;
case 128: /* Unchanged */
break;
case 129: /* Negation */
pFont->usFontStyle ^= FONT_CAPITALS;
break;
default:
DBG_DEC(ucTmp);
DBG_FIXME();
break;
}
break;
case 0x083c: /* fVanish */
ucTmp = ucGetByte(iFodo + iFodoOff + 2, aucGrpprl);
switch (ucTmp) {
case 0: /* Unset */
pFont->usFontStyle &= ~FONT_HIDDEN;
break;
case 1: /* Set */
pFont->usFontStyle |= FONT_HIDDEN;
break;
case 128: /* Unchanged */
break;
case 129: /* Negation */
pFont->usFontStyle ^= FONT_HIDDEN;
break;
default:
DBG_DEC(ucTmp);
DBG_FIXME();
break;
}
break;
case 0x2a32: /* cDefault */
pFont->usFontStyle &= FONT_HIDDEN;
pFont->ucFontColor = FONT_COLOR_DEFAULT;
break;
case 0x2a33: /* cPlain */
DBG_MSG("2a33: cPlain");
vFillFontFromStylesheet(usIstd, pFont);
break;
case 0x2a3e: /* cKul */
ucTmp = ucGetByte(iFodo + iFodoOff + 2, aucGrpprl);
if (ucTmp == 0 || ucTmp == 5) {
pFont->usFontStyle &= ~FONT_UNDERLINE;
} else {
NO_DBG_MSG("Underline text");
pFont->usFontStyle |= FONT_UNDERLINE;
if (ucTmp == 6) {
DBG_MSG("Bold text");
pFont->usFontStyle |= FONT_BOLD;
}
}
break;
case 0x2a42: /* cIco */
pFont->ucFontColor =
ucGetByte(iFodo + iFodoOff + 2, aucGrpprl);
NO_DBG_DEC(pFont->ucFontColor);
break;
case 0x2a44: /* cHpsInc */
DBG_MSG("0x2a44: sprmCHpsInc");
ucTmp = ucGetByte(iFodo + iFodoOff + 2, aucGrpprl);
DBG_DEC(ucTmp);
break;
case 0x2a48: /* cIss */
ucTmp = ucGetByte(iFodo + iFodoOff + 2, aucGrpprl);
ucTmp &= 0x07;
if (ucTmp == 1) {
pFont->usFontStyle |= FONT_SUPERSCRIPT;
NO_DBG_MSG("Superscript");
} else if (ucTmp == 2) {
pFont->usFontStyle |= FONT_SUBSCRIPT;
NO_DBG_MSG("Subscript");
}
break;
case 0x4a30: /* cIstd */
usTmp = usGetWord(iFodo + iFodoOff + 2, aucGrpprl);
NO_DBG_DEC(usTmp);
break;
case 0x4a43: /* cHps */
pFont->usFontSize =
usGetWord(iFodo + iFodoOff + 2, aucGrpprl);
NO_DBG_DEC(pFont->usFontSize);
break;
case 0x4a4d: /* cHpsMul */
DBG_MSG("0x4a4d: sprmCHpsMul");
usTmp = usGetWord(iFodo + iFodoOff + 2, aucGrpprl);
DBG_DEC(usTmp);
break;
case 0x4a4f: /* cFtc0 */
usFtc0 = usGetWord(iFodo + iFodoOff + 2, aucGrpprl);
break;
case 0x4a50: /* cFtc1 */
usFtc1 = usGetWord(iFodo + iFodoOff + 2, aucGrpprl);
break;
case 0x4a51: /* cFtc2 */
usFtc2 = usGetWord(iFodo + iFodoOff + 2, aucGrpprl);
break;
case 0xca47: /* cMajority */
DBG_MSG("0xca47: sprmCMajority");
break;
case 0xca4a: /* cHpsInc1 */
usTmp = usGetWord(iFodo + iFodoOff + 2, aucGrpprl);
lTmp = (long)pFont->usFontSize + (long)usTmp;
if (lTmp < 8) {
pFont->usFontSize = 8;
} else if (lTmp > 32766) {
pFont->usFontSize = 32766;
} else {
pFont->usFontSize = (USHORT)lTmp;
}
break;
case 0xca4c: /* cMajority50 */
DBG_MSG("0xca4c: sprmCMajority50");
break;
case 0xea3f: /* cHps, cHpsPos */
ucTmp = ucGetByte(iFodo + iFodoOff + 2, aucGrpprl);
DBG_DEC(ucTmp);
if (ucTmp != 0) {
pFont->usFontSize = (USHORT)ucTmp;
}
ucTmp = ucGetByte(iFodo + iFodoOff + 3, aucGrpprl);
DBG_DEC(ucTmp);
break;
default:
break;
}
iInfoLen = iGet8InfoLength(iFodo + iFodoOff, aucGrpprl);
fail(iInfoLen <= 0);
iFodoOff += iInfoLen;
}
/* Combine the Ftc's to a FontNumber */
NO_DBG_DEC_C(usFtc0 != USHRT_MAX, usFtc0);
NO_DBG_DEC_C(usFtc2 != USHRT_MAX, usFtc2);
NO_DBG_DEC_C(usFtc1 != USHRT_MAX, usFtc1);
if (usFtc0 <= 0x7fff) {
if (usFtc0 <= (USHORT)UCHAR_MAX) {
pFont->ucFontNumber = (UCHAR)usFtc0;
} else {
DBG_DEC(usFtc0);
DBG_FIXME();
pFont->ucFontNumber = 0;
}
} else if (usFtc2 <= 0x7fff) {
if (usFtc2 <= (USHORT)UCHAR_MAX) {
pFont->ucFontNumber = (UCHAR)usFtc2;
} else {
DBG_DEC(usFtc2);
DBG_FIXME();
pFont->ucFontNumber = 0;
}
} else if (usFtc1 <= 0x7fff) {
if (usFtc1 <= (USHORT)UCHAR_MAX) {
pFont->ucFontNumber = (UCHAR)usFtc1;
} else {
DBG_DEC(usFtc1);
DBG_FIXME();
pFont->ucFontNumber = 0;
}
}
} /* end of vGet8FontInfo */
static UINT32 DrvPower_GetBatteryLevel(void)
{
static UINT32 uiPreBatteryLvl = DRVPWR_BATTERY_LVL_UNKNOWN;
static UINT32 uiPreBatteryADC = 0;
static UINT32 uiRetBatteryLvl;
static UINT32 uiEmptycount =0;
static UINT32 uiCount = 0;
UINT32 uiCurBatteryADC, uiCurBatteryLvl,i;
BOOL isMatch = FALSE;
uiCurBatteryLvl = 0;
if(uiPreBatteryLvl== DRVPWR_BATTERY_LVL_UNKNOWN)
{
uiCurBatteryADC = DrvPower_GetBatteryADC();
uiPreBatteryADC = DrvPower_GetBatteryADC()-1;
for (i = 0; i<BATT_SLIDE_WINDOW_COUNT; i++)
{
uiBattADCSlideWin[i] = uiCurBatteryADC;
DBG_MSG("AVG=%d\r\n",uiCurBatteryADC);
}
}
else
{
uiCurSlideWinCnt = BATT_SLIDE_WINDOW_COUNT;
uiBattADCSlideWin[uiBattSlideIdx++] = DrvPower_GetBatteryADC();
if (uiBattSlideIdx >= uiCurSlideWinCnt)
{
uiBattSlideIdx = 0;
}
uiCurBatteryADC = 0;
for (i = 0; i<uiCurSlideWinCnt; i++)
{
uiCurBatteryADC+=uiBattADCSlideWin[i];
DBG_MSG("A[%d]=%d,",i,uiBattADCSlideWin[i]);
}
uiCurBatteryADC/=uiCurSlideWinCnt;
DBG_MSG("AVG=%d",uiCurBatteryADC);
DBG_MSG(", V=%d",uiCurBatteryADC*42/9100);
DBG_MSG(".%02d\r\n",(uiCurBatteryADC*42/91)%100);
}
//DBG_IND("%d,%d,%d\r\n",VOLDET_BATTERY_ADC_LVL0,VOLDET_BATTERY_ADC_LVL1,VOLDET_BATTERY_ADC_LVL2);
// Rising
if (uiCurBatteryADC > uiPreBatteryADC)
{
for (i=BATT_LEVEL_COUNT; i>0; i--)
{
if (uiCurBatteryADC > pBattAdcLevelValue[i-1])
{
uiCurBatteryLvl = i;
isMatch = TRUE;
break;
}
}
if (isMatch != TRUE)
{
uiCurBatteryLvl = 0;
}
}
// Falling
else
{
for (i=BATT_LEVEL_COUNT; i>0; i--)
{
if (uiCurBatteryADC > pBattAdcLevelValue[i-1])
{
uiCurBatteryLvl = i;
isMatch = TRUE;
break;
}
}
if (isMatch != TRUE)
{
uiCurBatteryLvl = 0;
}
}
// Debounce
if ((uiCurBatteryLvl == uiPreBatteryLvl) ||
(uiPreBatteryLvl == DRVPWR_BATTERY_LVL_UNKNOWN))
{
uiRetBatteryLvl = uiCurBatteryLvl;
}
uiPreBatteryLvl = uiCurBatteryLvl;
uiPreBatteryADC = uiCurBatteryADC;
if(uiCount % 2 == 0)
{
uiRetBatteryLvl = uiPreBatteryLvl;
}
uiCount++;
//
if(uiEmptycount|| uiRetBatteryLvl == DRVPWR_BATTERY_LVL_0)
{
uiEmptycount++;
if (uiEmptycount >= 15)
{
return DRVPWR_BATTERY_LVL_EMPTY;
}
}
return uiRetBatteryLvl;
}
int
main(int argc, char **argv)
{
options_type tOptions;
const char *szWordfile;
int iFirst, iIndex, iGoodCount;
BOOL bUsage, bMultiple, bUseTXT, bUseXML;
if (argc <= 0) {
return EXIT_FAILURE;
}
szTask = szBasename(argv[0]);
if (argc <= 1) {
iFirst = 1;
bUsage = TRUE;
} else {
iFirst = iReadOptions(argc, argv);
bUsage = iFirst <= 0;
}
if (bUsage) {
vUsage();
return iFirst < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
#if defined(N_PLAT_NLM) && !defined(_VA_LIST)
nwinit();
#endif /* N_PLAT_NLM && !_VA_LIST */
vGetOptions(&tOptions);
#if !defined(__dos)
if (is_locale_utf8()) {
#if defined(__STDC_ISO_10646__)
/*
* If the user wants UTF-8 and the envirionment variables
* support UTF-8, than set the locale accordingly
*/
if (tOptions.eEncoding == encoding_utf_8) {
if (setlocale(LC_CTYPE, "") == NULL) {
werr(1, "Can't set the UTF-8 locale! "
"Check LANG, LC_CTYPE, LC_ALL.");
}
DBG_MSG("The UTF-8 locale has been set");
} else {
(void)setlocale(LC_CTYPE, "C");
}
#endif /* __STDC_ISO_10646__ */
} else {
if (setlocale(LC_CTYPE, "") == NULL) {
werr(0, "Can't set the locale! Will use defaults");
(void)setlocale(LC_CTYPE, "C");
}
DBG_MSG("The locale has been set");
}
#endif /* !__dos */
bMultiple = argc - iFirst > 1;
bUseTXT = tOptions.eConversionType == conversion_text ||
tOptions.eConversionType == conversion_fmt_text;
bUseXML = tOptions.eConversionType == conversion_xml;
iGoodCount = 0;
#if defined(__dos)
if (tOptions.eConversionType == conversion_pdf) {
/* PDF must be written as a binary stream */
setmode(fileno(stdout), O_BINARY);
}
#endif /* __dos */
if (bUseXML) {
fprintf(stdout,
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
"<!DOCTYPE %s PUBLIC \"-//OASIS//DTD DocBook XML V4.1.2//EN\"\n"
"\t\"http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd\">\n",
bMultiple ? "set" : "book");
if (bMultiple) {
fprintf(stdout, "<set>\n");
}
}
for (iIndex = iFirst; iIndex < argc; iIndex++) {
if (bMultiple && bUseTXT) {
szWordfile = szBasename(argv[iIndex]);
fprintf(stdout, "::::::::::::::\n");
fprintf(stdout, "%s\n", szWordfile);
fprintf(stdout, "::::::::::::::\n");
}
if (bProcessFile(argv[iIndex])) {
iGoodCount++;
}
}
if (bMultiple && bUseXML) {
fprintf(stdout, "</set>\n");
}
DBG_DEC(iGoodCount);
return iGoodCount <= 0 ? EXIT_FAILURE : EXIT_SUCCESS;
} /* end of main */
