UINT32
SensorInfoSingleton_T::
impGetFlickerPara(MINT32 sensorMode, MVOID*const pDataBuf) const
{
XLOGD("impGetFlickerPara+ mode=%d", sensorMode);
XLOGD("prv=%d, vdo=%d, cap=%d, zsd=%d",
(int)e_sensorModePreview, (int)e_sensorModeVideoPreview, (int)e_sensorModeCapture, (int)e_sensorModeZsd );
FLICKER_CUST_PARA* para;
para = (FLICKER_CUST_PARA*)pDataBuf;
if(sensorMode==e_sensorModePreview)
get_flicker_para_by_preview(para);
else if(sensorMode==e_sensorModeZsd||
sensorMode==e_sensorModeVideoPreview ||
sensorMode==e_sensorModeCapture)
{
get_flicker_para_by_ZSD(para);
}
else
{
XLOGD("impGetFlickerPara ERROR ln=%d", __LINE__);
return -1;
}
XLOGD("impGetFlickerPara-");
return 0;
}
static unsigned int DumpToFile(
char *fname,
unsigned char *pbuf,
unsigned int size
)
{
int nw, cnt = 0;
unsigned int written = 0;
XLOGD("[DumpToFile] S_u4RunningNumber: %d.\n", S_u4RunningNumber);
XLOGD("[DumpToFile] opening file [%s]\n", fname);
FILE* pFp = fopen(fname, "a+t"); // a+: Opens for reading and appending. t: Open in text (translated) mode.
if (pFp < 0) {
XLOGE("[DumpToFile] failed to create file [%s]: %s", fname, strerror(errno));
return 0x80000000;
}
XLOGD("[DumpToFile] writing %d bytes to file [%s]\n", size, fname);
while (written < size) {
nw = fwrite(pbuf + written, sizeof( char ), size - written, pFp);
if (nw < 0) {
XLOGE("[DumpToFile] failed to write to file [%s]: %s", fname, strerror(errno));
break;
}
written += nw;
cnt++;
}
XLOGD("[DumpToFile] done writing %d bytes to file [%s] in %d passes\n", size, fname, cnt);
fclose(pFp);
return 0;
}
JNIEXPORT jboolean JNICALL Java_com_mediatek_engineermode_io_EmGpio_setSd30Mode
(JNIEnv * env, jobject obj, jint hostNum, jint sd30Mode, jint sd30MaxCurrent, jint sd30Drive, jint sd30PowerControl)
{
XLOGD("MSDC_JNI: hostNum=%d, sd30Mode = %d, sd30MaxCurrent=%d, sd30Drive = %d, sd30PowerControl=%d",
hostNum, sd30Mode, sd30MaxCurrent, sd30Drive, sd30PowerControl);
if(hostNum > MSDC_MAX_HOST_MUM || sd30Mode > 5 || sd30MaxCurrent > 3 || sd30Drive > 3 || sd30PowerControl > 1)
{
XLOGD("----error: hostNum or index error.\n");
return JNI_FALSE;
}
int sd_fd, ret;
struct msdc_ioctl command;
sd_fd = open("/dev/misc-sd", O_RDONLY);
if(sd_fd < 0)
{
XLOGD("----error: can't open misc-sd----, error code:%d\n", sd_fd);
return JNI_FALSE;
}
command.host_num = hostNum;
command.opcode = MSDC_SD30_MODE_SWITCH;
command.sd30_mode = sd30Mode;
command.sd30_max_current = sd30MaxCurrent;
command.sd30_drive = sd30Drive;
command.sd30_power_control = sd30PowerControl;
command.result = -1;
ret = ioctl(sd_fd, -1, (void *)&command);
if(ret < 0 || -1 == command.result)
{
XLOGD("----error: can't call misc-sd----, error:%d, fd:%d\n",ret, sd_fd);
return JNI_FALSE;
}
close(sd_fd);
return JNI_TRUE;
}
int cust_fillDefaultStrobeNVRam(int sensorDev, void* data)
{
if(sensorDev==DUAL_CAMERA_MAIN_SENSOR)
{
if(g_mainId==1)
{
XLOGD("devid main id1");
return cust_fillDefaultStrobeNVRam_main(data);
}
else
{
XLOGD("devid main id2");
return cust_fillDefaultStrobeNVRam_main2(data);
}
}
else
{
if(g_subId==1)
{
XLOGD("devid sub id1");
return cust_fillDefaultStrobeNVRam_sub(data);
}
else
{
XLOGD("devid sub id2");
return cust_fillDefaultStrobeNVRam_sub2(data);
}
}
}
void cust_getFlashQuick2CalibrationExp(int sensorDev, int* exp, int* afe, int* isp)
{
if(sensorDev==DUAL_CAMERA_MAIN_SENSOR)
{
if(g_mainId==1)
{
XLOGD("cust_getFlashQuick2CalibrationExp devid main id1");
cust_getFlashQuick2CalibrationExp_main(exp, afe, isp);
}
else
{
XLOGD("cust_getFlashQuick2CalibrationExp devid main id2");
cust_getFlashQuick2CalibrationExp_main2(exp, afe, isp);
}
}
else
{
if(g_subId==1)
{
XLOGD("cust_getFlashQuick2CalibrationExp devid sub id1");
cust_getFlashQuick2CalibrationExp_sub(exp, afe, isp);
}
else
{
XLOGD("cust_getFlashQuick2CalibrationExp devid sub id2");
cust_getFlashQuick2CalibrationExp_sub2(exp, afe, isp);
}
}
}
void cust_getFlashITab1(int sensorDev, short* ITab1)
{
if(sensorDev==DUAL_CAMERA_MAIN_SENSOR)
{
if(g_mainId==1)
{
XLOGD("cust_getFlashITab1 devid main id1");
cust_getFlashITab1_main(ITab1);
}
else
{
XLOGD("cust_getFlashITab1 devid main id2");
cust_getFlashITab1_main2(ITab1);
}
}
else
{
if(g_subId==1)
{
XLOGD("cust_getFlashITab1 devid sub id1");
cust_getFlashITab1_sub(ITab1);
}
else
{
XLOGD("cust_getFlashITab1 devid sub id2");
cust_getFlashITab1_sub2(ITab1);
}
}
}
int DMAgent::setRecoveryCommand() {
XLOGD("Enter to save recovery command");
if (::file_exist(RECOVERY_COMMAND)) {
unlink(RECOVERY_COMMAND);
}
int fd = open(RECOVERY_COMMAND, O_CREAT | O_WRONLY | O_TRUNC, 0746);
if (fd == -1) {
XLOGE("Open RECOVERY_COMMAND error: [%d]\n",errno);
return 0;
}
char command[] = "--fota_delta_path=/data/delta";
int len = sizeof(command);
XLOGD("recovery command lenth is [%d]\n", len);
int count = write(fd, command, len);
sync();
XLOGD("--recovery command sync--");
close(fd);
if (count < 0 || count != len) {
XLOGE("Recovery command write error or the count =[%d] is not the len",
count);
return 0;
}
return 1;
}
int DMAgent::getLockType() {
//0 -partially lock 1- fully lock
if (::file_exist(DM_LOCK_PATH)) {
//if file exist then get the type
int lock_fd = open(DM_LOCK_PATH, O_RDONLY);
if (lock_fd == -1) {
XLOGE("read lock file fd is -1");
return -1;
} else {
// get file size
struct stat file_stat;
bzero(&file_stat, sizeof(file_stat));
stat(DM_LOCK_PATH, &file_stat);
//int size=file_stat.st_size-1;
int size = file_stat.st_size;
XLOGD("read lock file size is %d", size);
char *buff = (char *) malloc(size);
read(lock_fd, buff, size);
close(lock_fd);
XLOGD("Read lock file buff = [%s]\n", buff);
if (strncmp(buff, "partially", 9) == 0) {
XLOGD("Partially lock");
return 0;
} else if (strncmp(buff, "fully", 5) == 0) {
XLOGD("fully lock");
return 1;
} else {
XLOGE("Not partially lock and fully lock, error!");
return -1;
}
}
} else
return NO_ERROR;
}
int main(int argc, char** argv)
{
int actionID=0, RegBase = 0, RegValue = 0, err = 0;
char fileName[256];
XLOGD("MJC test...");
//add MJC test code here
XLOGD("MJC init end !");
return 0;
}
JNIEXPORT jboolean JNICALL Java_com_mediatek_engineermode_io_EmGpio_newSetCurrent
(JNIEnv * env, jobject obj, jint hostNum, jint clkPU, jint clkPD, jint cmdPU, jint cmdPD, jint datPU, jint datPD, jint hopBit , jint hopTime,jint opcode)
{
if(hostNum > MSDC_MAX_HOST_MUM || clkPU >7 || clkPD >7 || cmdPU >7 || cmdPD >7 || datPU >7 || datPD >7 || hopBit >3 || hopTime > 5)
{
XLOGD("----error: hostNum or currentIdx too large.\n");
return JNI_FALSE;
}
int sd_fd, ret;
struct msdc_ioctl command;
sd_fd = open("/dev/misc-sd", O_RDONLY);
if(sd_fd < 0)
{
XLOGD("----error: can't open misc-sd----, error code:%d\n", sd_fd);
return JNI_FALSE;
}
XLOGD("set: clk_pu=%d, clk_pd = %d, cmd_pu=%d, cmd_pd = %d, dat_pu=%d, dat_pd = %d\r\n",
clkPU, clkPD, cmdPU, cmdPD, datPU, datPD);
XLOGD("set: l_hopBitIdx=%d, l_hopTimeIdx = %d, opcode = %d\r\n",hopBit, hopTime, opcode);
if(opcode == 0){
command.opcode = MSDC_DRIVING_SETTING;
}else{
command.opcode = MSDC_HOPPING_SETTING;
}
command.host_num =hostNum; //0~3
command.clk_pu_driving = clkPU;
command.clk_pd_driving = clkPD;
command.cmd_pu_driving = cmdPU;
command.cmd_pd_driving = cmdPD;
command.dat_pu_driving = datPU;
command.dat_pd_driving = datPD;
command.hopping_bit = hopBit;
command.hopping_time = hopTime;
command.iswrite =1; //0: read, 1:write
command.clock_freq =0;
command.result = -1;
ret = ioctl(sd_fd, -1, (void *)&command);
if(ret < 0 || -1 == command.result)
{
XLOGD("----error: can't call misc-sd----, error:%d, fd:%d\n",ret, sd_fd);
return JNI_FALSE;
}
close(sd_fd);
return JNI_TRUE;
}
static void printProcInfo(TO3D_SET_PROC_INFO_STRUCT *info)
{
XLOGD("dump PROC_INFO_STRUCT");
XLOGD("output_image_width: %d", info->output_image_width);
XLOGD("output_image_height: %d", info->output_image_height);
XLOGD("large_image_addr: %x", info->large_image_addr);
XLOGD("small_image_addr: %x", info->small_image_addr);
XLOGD("output_image_addr: %x", info->output_image_addr);
XLOGD("angle: %d", info->angle);
XLOGD("large_image_texID: %d", info->large_image_texID);
XLOGD("output_image_texID: %d", info->output_image_texID);
XLOGD("output_image_fboID: %d", info->output_image_fboID);
}
status_t EventThread::Connection::postEvent(
const DisplayEventReceiver::Event& event) {
#ifdef MTK_AOSP_ENHANCEMENT
#ifndef MTK_USER_BUILD
if (event.header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC)
XLOGD("postEvent(%d, v/c=%d)", pid, event.vsync.count);
else
XLOGD("postEvent(%d)", pid);
#endif
#endif
ssize_t size = DisplayEventReceiver::sendEvents(mChannel, &event, 1);
return size < 0 ? status_t(size) : status_t(NO_ERROR);
}
char* DMAgent::readMiscPartition(int readSize) {
int fd;
int result;
int iRealReadSize = readSize;
char *readBuf = (char *) malloc(iRealReadSize);
if (NULL == readBuf) {
XLOGE("[readMiscPartition] : malloc error");
return NULL;
}
memset(readBuf, '\0', iRealReadSize);
// int miscPartition = miscNum; //we can get this num from SS6
int readEndBlock = 2048;
// XLOGD("[ReadMiscPartion]:misc number is [%d] read size is [%d]\r\n",
// miscPartition, iRealReadSize);
struct mtd_info_user info;
char devName[32];
memset(devName, '\0', sizeof(devName));
//sprintf(devName,"/dev/mtd/mtd%d",miscPartition);
sprintf(devName, MISC_PATH);
fd = open(devName, O_RDWR);
if (fd < 0) {
XLOGD("[ReadMiscPartition]:mtd open error\r\n");
return NULL;
}
#ifndef MTK_EMMC_SUPPORT
//need lseek 2048 for NAND only
result = lseek(fd, readEndBlock, SEEK_SET);
if (result != (readEndBlock)) {
XLOGE("[ReadMiscPartition]:mtd lseek error\r\n");
return NULL;
}
#endif
//read from misc partition to make sure it is correct
result = read(fd, readBuf, iRealReadSize);
if (result != iRealReadSize) {
XLOGE("[ReadMiscPartition]:mtd read error\r\n");
free(readBuf);
readBuf = NULL;
close(fd);
return NULL;
}
XLOGD("[ReadMiscPartition]:end to read readbuf = %s\r\n", readBuf);
close(fd);
return readBuf;
}
int getDefaultStrobeNVRam(int sensorType, void* data, int* ret_size)
{
if(sensorType==(int)DUAL_CAMERA_SUB_SENSOR)
{
XLOGD("getDefaultStrobeNVRam ln=%d sensorId=%d",__LINE__, sensorType);
return getDefaultStrobeNVRam_sub(data, ret_size);
}
else //DUAL_CAMERA_MAIN_SENSOR
{
XLOGD("getDefaultStrobeNVRam ln=%d sensorId=%d",__LINE__, sensorType);
return getDefaultStrobeNVRam_main(data, ret_size);
}
}
static void printInitInfo(TO3D_SET_ENV_INFO_STRUCT *info)
{
XLOGD("dump ENV_INFO_STRUCT");
XLOGD("large_image_width: %d", info->large_image_width);
XLOGD("large_image_height: %d", info->large_image_height);
XLOGD("small_image_width: %d", info->small_image_width);
XLOGD("small_image_height: %d", info->small_image_height);
XLOGD("large_image_format: %d", info->large_image_format);
XLOGD("small_image_format: %d", info->small_image_format);
XLOGD("to3d_scenario: %d", info->to3d_scenario);
XLOGD("to3d_tuning_data: %x", &(info->to3d_tuning_data));
}
void doApMcuTest(int index, int core_number, RPCClient* msgSender) {
const char* test_files[][CORE_NUMBER_8] = {
{FILE_VFP_0, FILE_VFP_1, FILE_VFP_2, FILE_VFP_3, FILE_VFP_4, FILE_VFP_5, FILE_VFP_6, FILE_VFP_7},
{FILE_CA7_0, FILE_CA7_1, FILE_CA7_2, FILE_CA7_3, FILE_CA7_4, FILE_CA7_5, FILE_CA7_6, FILE_CA7_7},
{FILE_DHRY_0, FILE_DHRY_1, FILE_DHRY_2, FILE_DHRY_3, FILE_DHRY_4, FILE_DHRY_5, FILE_DHRY_6, FILE_DHRY_7},
{FILE_MEMCPY_0, FILE_MEMCPY_1, FILE_MEMCPY_2, FILE_MEMCPY_3, FILE_MEMCPY_4, FILE_MEMCPY_5, FILE_MEMCPY_6, FILE_MEMCPY_7},
{FILE_FDCT_0, FILE_FDCT_1, FILE_FDCT_2, FILE_FDCT_3, FILE_FDCT_4, FILE_FDCT_5, FILE_FDCT_6, FILE_FDCT_7},
{FILE_IMDCT_0, FILE_IMDCT_1, FILE_IMDCT_2, FILE_IMDCT_3, FILE_IMDCT_4, FILE_IMDCT_5, FILE_IMDCT_6, FILE_IMDCT_7},
};
int chip = em_jni_get_chip_id();
XLOGD("chip id: %d", chip);
if (chip == MTK_6575_SUPPORT || chip == MTK_6577_SUPPORT
|| chip == MTK_6573_SUPPORT || chip == MTK_6516_SUPPORT) {
test_files[0][0] = FILE_NEON_0;
test_files[0][1] = FILE_NEON_1;
test_files[0][2] = FILE_NEON_2;
test_files[0][3] = FILE_NEON_3;
test_files[1][0] = FILE_CA9_0;
test_files[1][1] = FILE_CA9_1;
test_files[1][2] = FILE_CA9_2;
test_files[1][3] = FILE_CA9_3;
}
struct thread_status_t test_threads[CORE_NUMBER_8] = {
{ pid : 0, create_result : -1, },
int local_name_to_fd(const char *name)
{
int port;
if(!strncmp("tcp:", name, 4)){
int ret;
port = atoi(name + 4);
ret = socket_loopback_server(port, SOCK_STREAM);
return ret;
}
#ifndef HAVE_WIN32_IPC /* no Unix-domain sockets on Win32 */
// It's non-sensical to support the "reserved" space on the adb host side
if(!strncmp(name, "local:", 6)) {
return socket_local_server(name + 6,
ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
} else if(!strncmp(name, "localabstract:", 14)) {
return socket_local_server(name + 14,
ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
} else if(!strncmp(name, "localfilesystem:", 16)) {
return socket_local_server(name + 16,
ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM);
}
#endif
printf("unknown local portname '%s'\n", name);
XLOGD("unknown local portname '%s'\n", name);
return -1;
}
bool LayerScreenshot::isFrozen() {
Mutex::Autolock _l(gLock);
int count = gLayerStatus.size();
if (count <= 0) return false;
LayerStatus top = gLayerStatus.valueAt(0);
int identity = gLayerStatus.keyAt(0);
for (int i = 1; i < count; i++) {
LayerStatus state = gLayerStatus.valueAt(i);
if (state.z > top.z) {
top = state;
identity = gLayerStatus.keyAt(i);
}
}
XLOGI("[%s] LayerScreenshot top:%d (orient:%d, alpha:%d)",
__func__, identity, top.orient, top.alpha);
if ((top.orient & Transform::ROT_INVALID) || (0xff > top.alpha)) {
XLOGI(" No need to freeze screen...");
return false;
}
XLOGD(" Freeze screen...");
return true;
}
void handle_offline(atransport *t)
{
D("adb: offline\n");
XLOGD("adb: offline\n");
//Close the associated usb
run_transport_disconnects(t);
}
bool dumpAlphaTexture(int width, int height, uint8_t *data, const char *prefix, SkBitmap::Config format)
{
static int count = 0;
char procName[256];
char file[512];
SkBitmap bitmap;
SkBitmap bitmapCopy;
if (!getProcessName(procName, sizeof(procName)))
return false;
sprintf(file, "/data/data/%s/%s_%04d.png", procName, prefix, count++);
XLOGI("%s: %dx%d %s\n", __FUNCTION__, width, height, file);
bitmap.setConfig(format, width, height);
bitmap.setPixels(data, NULL);
if (!bitmap.copyTo(&bitmapCopy, SkBitmap::kARGB_8888_Config))
{
XLOGD("%s: Failed to copy data", __FUNCTION__);
return false;
}
if (!SkImageEncoder::EncodeFile(file, bitmapCopy, SkImageEncoder::kPNG_Type, 100))
{
XLOGE("%s: Failed to encode image %s\n", __FUNCTION__, file);
return false;
}
return true;
}
static void listener_event_func(int _fd, unsigned ev, void *_l)
{
alistener *l = _l;
asocket *s;
if(ev & FDE_READ) {
struct sockaddr addr;
socklen_t alen;
int fd;
alen = sizeof(addr);
fd = adb_socket_accept(_fd, &addr, &alen);
if(fd < 0) return;
s = create_local_socket(fd);
if(s) {
s->transport = l->transport;
connect_to_remote(s, l->connect_to);
return;
}
D("listener_event_func adb_close \n");
XLOGD("listener_event_func adb_close \n");
adb_close(fd);
}
}
//==============================================================================
//
//==============================================================================
static void copyTuningPara(FLASH_TUNING_PARA* p, NVRAM_FLASH_TUNING_PARA* nv_p)
{
p->yTarget=nv_p->yTarget;
p->fgWIncreaseLevelbySize=nv_p->fgWIncreaseLevelbySize;
p->fgWIncreaseLevelbyRef=nv_p->fgWIncreaseLevelbyRef;
p->ambientRefAccuracyRatio=nv_p->ambientRefAccuracyRatio;
p->flashRefAccuracyRatio=nv_p->flashRefAccuracyRatio;
p->backlightAccuracyRatio=nv_p->backlightAccuracyRatio;
p->backlightUnderY = nv_p->backlightUnderY;
p->backlightWeakRefRatio = nv_p->backlightWeakRefRatio;
p->safetyExp=nv_p->safetyExp;
p->maxUsableISO=nv_p->maxUsableISO;
p->yTargetWeight=nv_p->yTargetWeight;
p->lowReflectanceThreshold=nv_p->lowReflectanceThreshold;
p->flashReflectanceWeight=nv_p->flashReflectanceWeight;
p->bgSuppressMaxDecreaseEV=nv_p->bgSuppressMaxDecreaseEV;
p->bgSuppressMaxOverExpRatio=nv_p->bgSuppressMaxOverExpRatio;
p->fgEnhanceMaxIncreaseEV=nv_p->fgEnhanceMaxIncreaseEV;
p->fgEnhanceMaxOverExpRatio=nv_p->fgEnhanceMaxOverExpRatio;
p->isFollowCapPline=nv_p->isFollowCapPline;
p->histStretchMaxFgYTarget=nv_p->histStretchMaxFgYTarget;
p->histStretchBrightestYTarget=nv_p->histStretchBrightestYTarget;
p->fgSizeShiftRatio = nv_p->fgSizeShiftRatio;
p->backlitPreflashTriggerLV = nv_p->backlitPreflashTriggerLV;
p->backlitMinYTarget = nv_p->backlitMinYTarget;
XLOGD("copyTuningPara main 2ndPart yTarget=%d", p->yTarget);
}
void * apmcu_test(void * argvoid) {
struct thread_params_t * arg = (struct thread_params_t *) argvoid;
int fd = -1;
char value[10] = { 0 };
size_t s = 0;
do {
fd = open(arg->file, O_RDWR);
XLOGD("open file: %s", arg->file);
if (fd < 0) {
snprintf(arg->result, sizeof(arg->result), "%s",
"fail to open device");
XLOGE("fail to open device");
break;
}
snprintf(value, sizeof(value), "%d", 1);
write(fd, value, strlen(value));
lseek(fd, 0, SEEK_SET);
s = read(fd, arg->result, sizeof(arg->result));
if (s <= 0) {
snprintf(arg->result, sizeof(arg->result), "%s",
"could not read response");
break;
}
} while (0);
if (fd >= 0) {
close(fd);
}
pthread_exit(NULL);
return NULL;
}
static void ss_listener_event_func(int _fd, unsigned ev, void *_l)
{
asocket *s;
if(ev & FDE_READ) {
struct sockaddr addr;
socklen_t alen;
int fd;
alen = sizeof(addr);
fd = adb_socket_accept(_fd, &addr, &alen);
if(fd < 0) return;
adb_socket_setbufsize(fd, CHUNK_SIZE);
s = create_local_socket(fd);
if(s) {
connect_to_smartsocket(s);
return;
}
D("ss_listener_event_func adb_close \n");
XLOGD("ss_listener_event_func adb_close \n");
adb_close(fd);
}
}
void * swcodec_test(void * argvoid) {
struct thread_params_t * arg = (struct thread_params_t *) argvoid;
int tid = gettid();
XLOGD("tid: %d, Enter swcodec_test: file: %s", tid, arg->file);
FILE * fp;
struct timeval timeout;
struct timeval delay;
delay.tv_sec = 0;
delay.tv_usec = 100 * 1000;
do {
pthread_mutex_lock(&lock);
fp = popen(arg->file, "r");
pthread_mutex_unlock(&lock);
select(0, NULL, NULL, NULL, &delay);
if (fp == NULL) {
XLOGE("popen fail: %s, errno: %d", arg->file, errno);
strcpy(arg->result, "POPEN FAIL\n");
break;
}
char *ret;
while(1) {
pthread_mutex_lock(&lock);
ret = fgets(arg->result, sizeof(arg->result), fp);
pthread_mutex_unlock(&lock);
select(0, NULL, NULL, NULL, &delay);
if (ret == NULL) {
XLOGD("tid: %d, get result is null", tid);
break;
}
}
} while(0);
if (fp != NULL) {
pthread_mutex_lock(&lock);
int closeRet = pclose(fp);
pthread_mutex_unlock(&lock);
select(0, NULL, NULL, NULL, &delay);
while (closeRet == -1) {
pthread_mutex_lock(&lock);
closeRet = pclose(fp);
pthread_mutex_unlock(&lock);
select(0, NULL, NULL, NULL, &delay);
}
XLOGD("after pclose, tid: %d, errno: %d", tid, errno);
}
pthread_exit(NULL);
return NULL;
}
// AED Exported Functions
static int aee_ioctl_wdt_kick(int value)
{
int ret=0;
int fd = open(AE_WDT_POWERKEY_DEVICE_PATH, O_RDONLY);
if (fd < 0) {
XLOGD("[SF-WD] ERROR: open %s failed.\n", AE_WDT_DEVICE_PATH);
return 1;
} else {
if (ioctl(fd, AEEIOCTL_WDT_KICK_POWERKEY, (int)value) != 0) {
XLOGD("[SF-WD] ERROR: aee wdt kick powerkey ioctl failed.\n");
close (fd);
return 1;
}
}
close (fd);
return ret;
}
void EventThread::Connection::setVsyncRate(uint32_t count) {
#ifdef MTK_AOSP_ENHANCEMENT
#ifndef MTK_USER_BUILD
XLOGD("setVsyncRate(%d, c=%d)", pid, count);
#endif
#endif
mEventThread->setVsyncRate(count, this);
}
int DMAgent::readOtaResult() {
int result;
get_ota_result(&result);
XLOGD("ota_result=%d\n", result);
return result;
}
void EventThread::Connection::requestNextVsync() {
#ifdef MTK_AOSP_ENHANCEMENT
#ifndef MTK_USER_BUILD
XLOGD("requestNextVsync(%d)", pid);
#endif
#endif
mEventThread->requestNextVsync(this);
}
// 20120814: add property function for debug purpose
void HWComposer::VSyncThread::setProperty() {
char value[PROPERTY_VALUE_MAX];
property_get("debug.sf.sw_vsync_fps", value, "0");
int fps = atoi(value);
if (fps > 0) {
mRefreshPeriod = nsecs_t(1e9 / fps);
XLOGD("[VSYNC] set sw vsync fps(%d), period(%" PRId64 ")", fps, mRefreshPeriod);
}
}
