C++ DBG_ERR函数代码示例

void System_OnStrgInit_INMEM(void)
{
    static BOOL bStrg_init_INMEM = FALSE;
    UINT32 i=0;
    if(bStrg_init_INMEM)
        return;

    //check partition overlap
    //part 0(FW area) must match loader reserved size,and next area can not overlap previos area
    for(i=0;i<NAND_PARTITION_NUM;i++)
    {
        if(i==0)
        {
            if(NandPartition[i].uiPhySize<gBinInfo.ld.FWResvSize)
            {
               DBG_ERR("part0 %x < FWResvSize %x,cannot init\r\n",NandPartition[i].uiPhySize,gBinInfo.ld.FWResvSize);
               return;
            }
        }
        else
        {
            if(NandPartition[i].uiPhyAddr<NandPartition[i-1].uiPhyAddr+NandPartition[i-1].uiPhySize)
            {
                DBG_ERR("part%d start %x overlap part%d end %x,cannot init\r\n",i,NandPartition[i].uiPhyAddr,i-1,NandPartition[i-1].uiPhyAddr+NandPartition[i-1].uiPhySize);
                return;
            }
        }
    }

    for(i=0;i<NAND_PARTITION_NUM;i++)
    {
        DX_HANDLE DxNandDev = Dx_GetObject(NandPartition[i].uiDxClassType);
        UserNandInit.buf.Addr = OS_GetMempoolAddr(POOL_ID_STORAGE_NAND);
        UserNandInit.buf.Size = OS_GetMempoolSize(POOL_ID_STORAGE_NAND);
        UserNandInit.prt.uiDxClassType = NandPartition[i].uiDxClassType;
        UserNandInit.prt.uiPhyAddr = NandPartition[i].uiPhyAddr;
        UserNandInit.prt.uiPhySize = NandPartition[i].uiPhySize;
        if(i==0)
            UserNandInit.prt.uiResvSize = gBinInfo.ld.LdBlockCount; //FWS use loader block count as reserved blcok
        else
            UserNandInit.prt.uiResvSize = NandPartition[i].uiResvSize;
        Dx_Init(DxNandDev,&UserNandInit,0,STORAGE_VER);
    }

    bStrg_init_INMEM = TRUE;
}

void DrvTV_TurnOn(void)
{
    DISPDEV_ID dev;
    DBG_FUNC_BEGIN("\r\n");
    if (g_localMode == DISP_TVMODE_NTSC)
    {
        dev = DISPDEV_ID_TVNTSC; //NTSC: 640x448
    }
    else if(g_localMode == DISP_TVMODE_PAL)
    {
        dev = DISPDEV_ID_TVPAL; //PAL: 640x528
    }
    else
    {
        DBG_ERR("mode=%d not support!\r\n", g_localMode);
        return;
    }
    // Init TV object
    /*
    pDev->SEL.GET_PREDISPSIZE.DevID = dev;
    pObj->devCtrl(DISPDEV_GET_PREDISPSIZE,pDev);
    g_localSize.w     = pDev->SEL.GET_PREDISPSIZE.uiBufWidth;
    g_localSize.h    = pDev->SEL.GET_PREDISPSIZE.uiBufHeight;
    */
    //IMPORTANT! for FAST BOOT, Photo App will ask disp size very early~
    //Update size of first mode (before open)
    //DxDisplay_UpdateModeInfo(g_TVDout<<4, g_localMode, &g_localSize);

    pDev->SEL.OPEN_DEVICE.DevID = dev;
    pObj->devCtrl(DISPDEV_OPEN_DEVICE,pDev);
    g_TVBacklightEn = TRUE;

    pObj->devCtrl(DISPDEV_GET_DISPSIZE,pDev);
    g_localSize.w = pDev->SEL.GET_DISPSIZE.uiBufWidth;
    g_localSize.h = pDev->SEL.GET_DISPSIZE.uiBufHeight;
    if(pCurrentSize)
        pCurrentSize[0] = g_localSize;

    // Enable IDE
    pObj->waitFrmEnd();
    pCtrl->SEL.SET_ENABLE.bEn = TRUE;
    pObj->dispCtrl(DISPCTRL_SET_ENABLE,pCtrl);


#if 0
    {
    int i;
    // Delay to wait for IDE stable
    for (i=6; i>0; i--)
    {
        //ide_wait_frame_end();
        pObj->waitFrmEnd();
    }
    }
#endif

    g_TVMode = g_localMode;
}

/*
    PreGet LCD size

    PreGet LCD size

    @param[in] pDevIF   Please refer to dispdevctrl.h for details.
    @param[in] uiAddr   LCD Register Offset.
    @param[in] uiValue  Assigned LCD Register Value

    @return void
*/
static ER dispdev_getLcdMiSize(DISPDEV_GET_PRESIZE *tSize)
{
    UINT32                  i;
    tLCD_PARAM              *pMode      = NULL;
    tLCD_PARAM              *pConfigMode= NULL;
    PINMUX_LCDINIT          LcdMode;
    UINT32                  ModeNumber;
    PINMUX_FUNC_ID          PinFuncID;
    //DISPDEV_IOCTRL_PARAM    DevIOCtrl;
#if   (DISPLCDSEL_IFMI_TYPE == DISPLCDSEL_IFMI_LCD1)
    DISPDEV_IOCTRL          pDispDevControl = pIFMiIoControl1;
#elif (DISPLCDSEL_IFMI_TYPE == DISPLCDSEL_IFMI_LCD2)
    DISPDEV_IOCTRL          pDispDevControl = pIFMiIoControl2;
#endif


    dispanl_debug(("getLcdSize START\r\n"));

    if(pDispDevControl == NULL)
    return E_PAR;

    tSize->uiBufWidth = 0;
    tSize->uiBufHeight = 0;

    //
    //  Sortig the SysInit Config Mode support
    //
#if (DISPLCDSEL_IFMI_TYPE == DISPLCDSEL_IFMI_LCD1)
    PinFuncID = PINMUX_FUNC_ID_LCD;
#elif ((DISPLCDSEL_IFMI_TYPE == DISPLCDSEL_IFMI_LCD2))
    PinFuncID = PINMUX_FUNC_ID_LCD2;
#endif
    LcdMode = pinmux_getDispMode(PinFuncID);
    pConfigMode = dispdev_getConfigModeMI(&ModeNumber);
    if((pConfigMode != NULL)&&(ModeNumber>0))
    {
        for(i=0;i<ModeNumber;i++)
        {
            if(pConfigMode[i].Panel.LCDMode == LcdMode)
            {
                pMode = (tLCD_PARAM*)&pConfigMode[i];
                break;
            }
        }
    }

    if(pMode==NULL)
    {
        DBG_ERR("LCDMode=%d not support\r\n", LcdMode);
        return E_NOSPT;
    }
    else
    {
        tSize->uiBufWidth = pMode->Panel.uiBufferWidth;
        tSize->uiBufHeight = pMode->Panel.uiBufferHeight;
    }
    return E_OK;
}

INT32 Lens_Focus_AfterZoomChanged(void)
{

    if (Lens_Module_GetState() != LENS_STATE_IDLE)
    {
        if(Lens_Module_GetState() != LENS_STATE_ZOOMMOVING)
        {
            DBG_ERR("%s, state incorrect, (%d)\r\n",__func__,Lens_Module_GetState());
            return ERR_OPERATION_FAIL;

        }
    }
    DBG_MSG("%s\r\n",__func__);
    if(Lens_Module_GetState() != LENS_STATE_ZOOMMOVING)
    {
        Lens_Module_SetState(LENS_STATE_FOCUSMOVING);
        DBG_MSG("LENS_STATE_FOCUSMOVING\r\n");    // --> LENS_STATE_FOCUSMOVING
    }

    //gLensCtrlObj.pLens->focus_afterZoomMoving(0);

    //if (category&FOCUS_PREEXC)
    {
        //Callback function
        if(gLensCtrlObj.APICB!=NULL)
        {
            gLensCtrlObj.APICB(LENS_CB_FOCUS_START, NULL);
        }

        gLensCtrlObj.pLens->focus_doExc(ON, 0);
    }

    /* Move focus to 2M distance. */
    #if 0
    gLensCtrlObj.pLens->focus_go2(Lens_Focus_GetTable(Lens_Zoom_GetSection(ZOOM_CUR_SECTION)-1, 2));
    #else
    //gLensCtrlObj.pLens->focus_afterZoomMoving(0);
    gLensCtrlObj.pLens->focus_afterZoomMoving(1);
    #endif

    //#NT#2010/08/19#Jeffery Chuang -end
    if(Lens_Module_GetState() != LENS_STATE_ZOOMMOVING)
    {
        gLensCtrlObj.pLens->focus_doExc(OFF, 0);
        Lens_Module_SetState(LENS_STATE_IDLE);
        DBG_MSG("LENS_STATE_IDLE\r\n");    // --> LENS_STATE_IDLE
    }
    else // Don't turn off motor driver power.
        LensCtrl_Focus_SetState(MOTOR_FOCUS_EXCITE_OFF,0);

    //Callback function
    if(gLensCtrlObj.APICB!=NULL)
    {
        gLensCtrlObj.APICB(LENS_CB_FOCUS_END, NULL);
    }

    return ERR_OK;
}

/**
    Get RAM disk Parameters
*/
static ER ramdsk_getParam(STRG_GET_PARAM_EVT uiEvt, UINT32 uiParam1, UINT32 uiParam2)
{
    ER  eRet = E_NOSPT;

    switch(uiEvt)
    {
    case STRG_GET_CAP_TAB:
    {
        memcpy((void *)uiParam1, (void *)&gRAMCap, sizeof(STRG_CAP));
        eRet = E_OK;
    }
    break;
    case STRG_GET_FAT_TABLE_PARAM:
    {
        UINT32 uiIndex=0;
        PSTRG_FATINFO strgFATInfo = (PSTRG_FATINFO)uiParam2;

        if(uiParam1 <= 8032)
        {   uiIndex = STRG_FAT_SIZE_4MB_8MB;  }
        else if ((uiParam1 > 8032) && (uiParam1 <= 16224))      // 8M
        {   uiIndex = STRG_FAT_SIZE_8MB_16MB;  }
        else if ((uiParam1 > 16224) && (uiParam1 <= 32448))     // 16M
        {   uiIndex = STRG_FAT_SIZE_16MB_32MB;  }
        else if ((uiParam1 > 32448) && (uiParam1 <= 64896))     // 32M
        {   uiIndex = STRG_FAT_SIZE_32MB_64MB;  }
        else if ((uiParam1 > 64896) && (uiParam1 <= 129792))    // 64M
        {   uiIndex = STRG_FAT_SIZE_64MB_128MB;  }
        else if ((uiParam1 > 129792) && (uiParam1 <= 259584))   // 128M
        {   uiIndex = STRG_FAT_SIZE_128MB_256MB;  }
        else if ((uiParam1 > 259584) && (uiParam1 <= 519168))   // 256M
        {   uiIndex = STRG_FAT_SIZE_256MB_512MB;  }
        else if ((uiParam1 > 519168) && (uiParam1 <= 1038336))  // 512M
        {   uiIndex = STRG_FAT_SIZE_512MB_1024MB;  }
        else if ((uiParam1 > 1038336) && (uiParam1 <= 2076672)) // 1024M
        {   uiIndex = STRG_FAT_SIZE_1024MB_2048MB;  }
        else if ((uiParam1 > 2076672) && (uiParam1 <= 4153344)) // 2048M
        {   uiIndex = STRG_FAT_SIZE_2048MB_4096MB;  }
        else if ((uiParam1 > 4153344) && (uiParam1 <= 8323072)) // 4096M
        {   uiIndex = STRG_FAT_SIZE_4096MB_8192MB; }
        else if((uiParam1 > 8323072) )
        {   uiIndex = STRG_FAT_SIZE_8192MB_16384MB; }

        strgFATInfo->uiHeadNum          = RamFATInfo[uiIndex][STRG_FAT_TBL_HEADNUM];
        strgFATInfo->uiSectorNum        = RamFATInfo[uiIndex][STRG_FAT_TBL_SECTORNUM];
        strgFATInfo->uiRelativeSector   = RamFATInfo[uiIndex][STRG_FAT_TBL_RELATIVESECTOR];
        strgFATInfo->uiSectorPerCluster = RamFATInfo[uiIndex][STRG_FAT_TBL_SECPERCLUSTER];
        strgFATInfo->uiResvSec          = RamFATInfo[uiIndex][STRG_FAT_TBL_RESERVEDSECTOR];
        eRet = E_OK;
    }
    break;

    default:
        DBG_ERR("No Implement! uiEvt %d\r\n",uiEvt);
        break;
    }

    return eRet;
}

/***************************************************************************
 *                                                                         *
 ***************************************************************************/
int net_get_info(char *ifname, struct NET_CONFIG *netcfg)
{
	struct ifreq ifr;
	int skfd;
	struct sockaddr_in *saddr;

	if ( (skfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {
		DBG_ERR("socket error");
		return -1;
	}

	saddr = (struct sockaddr_in *) &ifr.ifr_addr;
	strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
	if (ioctl(skfd, SIOCGIFADDR, &ifr) < 0) {
		DBG_ERR("net_get_info: ioctl SIOCGIFADDR");
		close(skfd);
		return -1;
	}
	netcfg->ifaddr = saddr->sin_addr.s_addr;
	DBG_NET("ifaddr=0x%x\n", netcfg->ifaddr);    

	if (ioctl(skfd, SIOCGIFNETMASK, &ifr) < 0) {
		DBG_ERR("net_get_info: ioctl SIOCGIFNETMASK");
		close(skfd);
		return -1;
	}
	netcfg->netmask = saddr->sin_addr.s_addr;
	DBG_NET("netmask=0x%x\n", netcfg->netmask);    

	if (ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0) {
		DBG_ERR("net_get_info: ioctl SIOCGIFHWADDR");
		close(skfd);
		return -1;
	}
	memcpy(netcfg->mac, ifr.ifr_ifru.ifru_hwaddr.sa_data, IFHWADDRLEN);
	DBG_NET("hwaddr=%02x:%02x:%02x:%02x:%02x:%02x\n", netcfg->mac[0],netcfg->mac[1],
					netcfg->mac[2],netcfg->mac[3],netcfg->mac[4],netcfg->mac[5]);

	close(skfd);
	netcfg->gateway = net_get_gateway();
	DBG_NET("gateway=0x%x\n", netcfg->gateway);    
	netcfg->dns = net_get_dns();
	return 0;

}

static int isp_gpio_init(struct device_node *fdt_node, struct sensor_pwd_info *spinfo)
{
    const char *sensors = NULL;

    DBG_INFO("");
    if (gpio_init(fdt_node, "reset-gpios", &spinfo->gpio_reset, 0)) {
        goto fail;
    }

    if (of_property_read_string(fdt_node, "sensors", &sensors)) {
        DBG_ERR("get sensors faild");
        goto free_reset;
    }

    if (!strcmp(sensors, "front")) {
        // default is power-down
        if (gpio_init(fdt_node, "pwdn-front-gpios", &spinfo->gpio_front, 1)) {
            goto free_reset;
        }
        spinfo->flag = SENSOR_FRONT;
    } else if (!strcmp(sensors, "rear")) {
        if (gpio_init(fdt_node, "pwdn-rear-gpios", &spinfo->gpio_rear, 1)) {
            goto free_reset;
        }
        spinfo->flag = SENSOR_REAR;
    } else if (!strcmp(sensors, "dual")) {
        if (gpio_init(fdt_node, "pwdn-front-gpios", &spinfo->gpio_front, 1)) {
            goto free_reset;
        }
        if (gpio_init(fdt_node, "pwdn-rear-gpios", &spinfo->gpio_rear, 1)) {
            gpio_exit(&spinfo->gpio_front, 1);
            goto free_reset;
        }
        spinfo->flag = SENSOR_DUAL;
    } else {
        DBG_ERR("sensors of dts is wrong");
        goto free_reset;
    }
    return 0;

  free_reset:
    gpio_exit(&spinfo->gpio_reset, 0);
  fail:
    return -1;
}

void System_OnStrgExit_FWS(void)
{
    ER er;
    er = FwSrv_Close();
    if(er != FWSRV_ER_OK)
    {
        DBG_ERR("Close failed!\r\n");
    }
}

int setbaud_psam_card(psam_cos_t *pc)
{
	u_char *buf = PSAM_COS_M(pc, buf);

	if (SAM_SET_BUAD(PSAM_COS_M(pc, slot), PSAM_COS_M(pc, baud)) != 0)
	{
		DBG_ERR("Send setbaud fail! (slot: %d)!", PSAM_COS_M(pc, slot));
		return -1;
	}

	if (SAM_GET_RESPONSE(PSAM_COS_M(pc, slot), buf) <= 0) 
	{
		DBG_ERR("Get setbaud response fail! (slot: %d)", PSAM_COS_M(pc, slot));
		return -1;
	}

	return 0;
}

static UINT32 WifiCmd_DispatchCmd(UINT32 cmd,WIFICMD_PAR_TYPE parType,UINT32 par,UINT32 *UserCB)
{
    int i = 0;
    UINT32 ret=0;

    if(g_receiver)
    {
        while(g_pCmdTab[i].cmd != 0)
        {
            if(cmd == g_pCmdTab[i].cmd)
            {
                //UINT32 t1,t2;
                //t1 = Perf_GetCurrent()/1000;
                DBG_IND("cmd:%d evt:%x par:%d CB:%x wait:%x\r\n",g_pCmdTab[i].cmd,g_pCmdTab[i].event,par,g_pCmdTab[i].usrCB,g_pCmdTab[i].Waitflag);
                if(g_pCmdTab[i].Waitflag)
                {
                    clr_flg(FLG_ID_WIFICMD, g_pCmdTab[i].Waitflag);
                    g_result = 0;
                }
                if(gEventHandle && g_pCmdTab[i].event)
                {
                    if(parType==WIFICMD_PAR_NUM)
                    {
                        gEventHandle(g_pCmdTab[i].event,1,par);
                    }
                    else if(parType==WIFICMD_PAR_STR)
                    {
                        char  *parStr;//post event,data in stack would release
                        parStr = WifiCmd_LockString();
                        memset(parStr,'\0',WIFI_PAR_STR_LEN);
                        sscanf((char *)par,"%s",parStr);
                        gEventHandle(g_pCmdTab[i].event,1,parStr);
                    }
                    else
                    {
                        gEventHandle(g_pCmdTab[i].event,0);
                    }
                }
                if(g_pCmdTab[i].Waitflag)
                    ret = WifiCmd_WaitFinish(g_pCmdTab[i].Waitflag);
                if(g_pCmdTab[i].usrCB)
                    *UserCB = (UINT32)g_pCmdTab[i].usrCB;
                //t2 = Perf_GetCurrent()/1000;
                //DBG_ERR("time %d ms\r\n",t2-t1);
                DBG_IND("ret %d\r\n",ret);
                return ret;
            }
            i++;
        }
    }
    else
    {
        DBG_ERR("should WifiCmd_ReceiveCmd enable\r\n");
    }
    return WIFI_CMD_NOT_FOUND;

}

/**
 * @brief    start dhcp
 * @param    "char *ifname" : [IN]interface name
 * @return    pid
 */
pid_t net_start_dhcpcd(char *ifname)
{
    pid_t pid;

    if ((pid = vfork()) == 0)
    {
        /* the child */
        execlp(DHCPC_EXEC_PATH, DHCPC_EXEC_PATH, ifname, NULL);
        DBG_ERR("exec dhcpcd failed");
        _exit(0);
    }
    else if (pid < 0)
    {
        DBG_ERR("fork dhcpcd failed");
        return  - 1;
    }
    return pid;
}

void Lens_SetMDSignal(MD_SIGNAL signal, BOOL on)
{
    if(gLensCtrlObj.pMotor)
        gLensCtrlObj.pMotor->setSignal(signal,on);
    else
    {
        DBG_ERR("Motor Obj not registered!\r\n");
    }
}

int get_file_size(char *file)
{
	FILE *tmp;
	int i = 0;

	tmp = fopen(file, "rb");
	DBG_ERR("file = %s", file);
	DBG_ERR("file* = %p", tmp);
	if (!tmp)
		return 0;

	fseek(tmp, 0, SEEK_END);
	i = ftell(tmp);
	DBG_ERR("size = %d", i);
	fclose(tmp);

	return i;
}

/***************************************************************************
 * Get a interface flag.                                                   *
 ***************************************************************************/
int net_get_flag(char *ifname)
{
	struct ifreq ifr;
	int skfd;

	if ( (skfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {
		DBG_ERR("socket error");
		return -1;
	}
	strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
	if (ioctl(skfd, SIOCGIFFLAGS, &ifr) < 0) {
		DBG_ERR("net_get_flag: ioctl SIOCGIFFLAGS");
		close(skfd);
		return -1;
	}
	close(skfd);
	return ifr.ifr_flags;
}

UINT32 DrvCARD2State(UINT32 StateID, UINT32 Value) // General Properties
{
    DBG_FUNC_BEGIN("\r\n");

    if(StateID & DXGET)
    {
    UINT32 rvalue =  0;
    StateID &= ~DXGET;
    DBG_IND("get %08x\r\n", StateID);
    switch(StateID)
    {
    case STORAGE_STATE_INSERT:
        rvalue = DrvCARD2_DetStrgCard();
        break;
    case STORAGE_STATE_LOCK:
        {
        BOOL bLock = FALSE;
        if(DrvCARD2_DetStrgCard())
        {
            bLock = DrvCARD2_DetStrgCardWP();
        }
        rvalue = bLock;
        }
        break;
        break;
    default:
        DBG_ERR("state=0x%02X not support!\r\n", StateID);
        break;
    }
    return rvalue;
    }
    else if(StateID & DXSET)
    {
    StateID &= ~DXSET;
    DBG_IND("set %08x\r\n", StateID);
    switch(StateID)
    {
    default:
        DBG_ERR("state=0x%02X not support!\r\n", StateID);
        break;
    }
    }
    return DX_OK;
}