int
client_writen(int fd, char *buf, size_t datalen, int timeout)
{
size_t nleft;
ssize_t nwritten;
const char *ptr;
ptr = buf;
nleft = datalen;
while (nleft > 0) {
if (timeout > 0 && timeout_wait(fd, timeout, 0) == -1) {
DERROR("write timeout\n");
break;
}
if ((nwritten = write(fd, ptr, nleft)) <= 0) {
if (nwritten < 0 && errno == EINTR) {
nwritten = 0;
} else {
DERROR("writen error: %s\n", strerror(errno));
return -1;
}
}
nleft -= nwritten;
ptr += nwritten;
}
return datalen-nleft;
}
bool CDisplayPlane::Create(void)
{
DENTRY();
m_lock = g_pIOS->CreateResourceLock();
if(!m_lock)
{
DERROR("failed to allocate resource lock\n");
return false;
}
DEBUGF2(2,("%s: node entries = %lu \n",__PRETTY_FUNCTION__,m_ulNodeEntries));
g_pIOS->AllocateDMAArea(&m_NodeListArea, (m_ulNodeEntries * sizeof(stm_plane_node)), 0, SDAAF_NONE);
g_pIOS->MemsetDMAArea(&m_NodeListArea, 0, 0, m_NodeListArea.ulDataSize);
if(!m_NodeListArea.pMemory)
{
DERROR("failed to allocate node list\n");
return false;
}
m_pNodeList = (stm_plane_node*)m_NodeListArea.pData;
DEXIT();
return true;
}
void GEnv::setState(SoundCompEvent* e)
{
DASSERT(e!=NULL);
if(e->empty())return;
if(e->getSize()!=sizeof(State))
{
DERROR("size missmatch");
if(e->getSize() < sizeof(State))return;
DERROR("trying to read...");
}
const State* s = (const State*)e->getData();
mode->setValue(s->mode);
if(mode->isPressed())
{
sig->setMode(EnvFollow::RMS);
}
else
{
sig->setMode(EnvFollow::PEAK);
}
per_knob->setValue(s->per);
updatePer();
}
static inline int
irnet_connect_tsap(irnet_socket * self)
{
int err;
DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self);
err = irnet_open_tsap(self);
if(err != 0)
{
clear_bit(0, &self->ttp_connect);
DERROR(IRDA_SR_ERROR, "connect aborted!\n");
return(err);
}
err = irttp_connect_request(self->tsap, self->dtsap_sel,
self->rsaddr, self->daddr, NULL,
self->max_sdu_size_rx, NULL);
if(err != 0)
{
clear_bit(0, &self->ttp_connect);
DERROR(IRDA_SR_ERROR, "connect aborted!\n");
return(err);
}
DEXIT(IRDA_SR_TRACE, "\n");
return(err);
}
/**
* @brief SD polling stataus function when send data.
* @param device_id[in]: Index of SD controller.
* @param pollbit[in]: Polling status bit.
* @return SP_TRUE: success, SP_FALSE: timeout or status fail.
*/
SP_BOOL WaitSDStatus_Data(
UINT32 device_id,
UINT32 pollbit)
{
sdReg_t *psdReg = (sdReg_t*) SetSDBase(device_id);
UINT32 init = jiffies;
do
{
/* ----- SD status error ----- */
if (psdReg->sdStatus & MASK_S_DataCRCError)
{
DERROR("data SD%d CRC error, CMD = 0x%x, STATUS = 0x%x\n", device_id, psdReg->sdCmd, psdReg->sdStatus);
return SP_FALSE;
}
/* ----- Timeout ----- */
if((jiffies-init)>=DATA_TIMEOUT)
{
DERROR("data SD%d timeout, CMD = 0x%x, STATUS = 0x%x\n", device_id, psdReg->sdCmd, psdReg->sdStatus);
return SP_FALSE;
}
} while((psdReg->sdStatus & pollbit)!=pollbit);
return SP_TRUE;
}
int test_sl_range(TestArgs *args)
{
MemLink *m;
int ret, i;
DINFO("====== sl_range ======\n");
if (args->longconn) {
m = memlink_create(args->host, args->rport, args->wport, args->timeout);
if (NULL == m) {
DERROR("memlink_create error!\n");
exit(-1);
return -1;
}
for (i = 0; i < args->testcount; i++) {
MemLinkResult result;
ret = memlink_cmd_rpop(m, args->table, args->key, args->len, &result);
if (ret != MEMLINK_OK) {
DERROR("range error! ret:%d\n", ret);
return -2;
}
if (result.count != args->len) {
DERROR("rpop result count error: %d, len:%d\n", result.count, args->len);
}
memlink_result_free(&result);
}
memlink_destroy(m);
} else {
}
return 0;
}
// execute dialog in a child process, leave it running
///////////////////////////////////////////////////////////////////////////////////////////
pid_t sdialog_call(const char* path,const char* msg)
{
pid_t pid;
DPRINTF("sdialog_call/fork\n");
if((pid=fork())<0)
{
DERROR("sdialog_call/fork");
return 0L;
}
if(pid==0)
{
DPRINTF("sdialog_call: in child\n");
DPRINTF("sdialog_call: DISPLAY=%s\n",getenv("DISPLAY"));
umask(0);
chdir("/");
DPRINTF("call_dialog: about to exec %s\n",path);
execlp(path,path,msg,(char*)0);
DERROR("sdialog_call/execlp");
exit(1);
}
DPRINTF("sdialog_call: child PID=%d\n",pid);
return pid;
}
int
client_readn(int fd, char *buf, int datalen, int timeout)
{
size_t nleft;
ssize_t nread;
char *ptr;
ptr = buf;
nleft = datalen;
while (nleft > 0) {
if (timeout > 0 && timeout_wait(fd, timeout, 1) == -1) {
DERROR("read timeout\n");
break;
}
if ((nread = read(fd, ptr, nleft)) == -1) {
if (errno == EINTR) {
nread = 0;
} else {
DERROR("readn error: %s\n", strerror(errno));
return -1;
}
} else if (nread == 0) {
DERROR("read 0, conn cloes\n");
break;
}
nleft -= nread;
ptr += nread;
}
return datalen-nleft;
}
//备切换成主
int
switch_master(int voteid, char *data, int datalen)
{
WThread *wt = g_runtime->wthread;
MasterInfo *minfo = wt->master_info;
if (g_cf->role == ROLE_MASTER) {
DERROR("master can not switch to master\n");
return -1;
} else if (g_cf->role == ROLE_BACKUP) {
DINFO("backup switch to master\n");
if (minfo != NULL) {
//销毁备上面以前保存得主节点得信息
event_del(&minfo->hb_timer_evt);
event_del(&minfo->hbevt);
if (minfo->hbsock > 0)
close(minfo->hbsock);
minfo->hbsock = -1;
wt->master_info = NULL;
zz_free(minfo);
//构建主节点上得备节点信息
master_init(voteid, data, datalen);
if (wt->clog->state == INCOMPLETE) {
int ret;
int cmdlen;
char *cmd = commitlog_get_cmd(wt->clog, &cmdlen);
pthread_mutex_lock(&g_runtime->mutex);
ret = wdata_apply(cmd, cmdlen, MEMLINK_NO_LOG, NULL);
DINFO("===wdata_apply ret: %d\n", ret);
if ( ret == 0) {
int sret;
sret = synclog_write(g_runtime->synclog, wt->clog->data, wt->clog->len);
if (sret < 0) {
DERROR("synclog_write error: %d\n", sret);
MEMLINK_EXIT;
}
char *cmd;
int cmdlen;
cmd = commitlog_get_cmd(wt->clog, &cmdlen);
sret = syncmem_write(g_runtime->syncmem, cmd, cmdlen,
g_runtime->synclog->version, g_runtime->synclog->index_pos - 1);
if (sret < 0) {
DERROR("syncmem_write error: %d\n", sret);
MEMLINK_EXIT;
}
}
pthread_mutex_unlock(&g_runtime->mutex);
}
} else {
DERROR("master info is null, can not switch\n");
return -3;
}
}
return 0;
}
int storage_license_check()
{
int ret, now, retry = 0, free_limit = 0;
long capacity;
uint32_t createtime;
struct stat buf;
char license[MAX_PATH_LEN];
#if 0
return 0;
#endif
if (cluster_is_solomode())
return 0;
retry:
ret = storage_get_createtime(&createtime);
if (ret) {
if (ret == EAGAIN) {
SLEEP_RETRY(err_ret, ret, retry, retry);
} else
GOTO(err_ret, ret);
}
now = time(NULL);
snprintf(license, MAX_PATH_LEN, "%s/license", gloconf.home);
ret = stat(license, &buf);
if (!ret) {
if ((buf.st_size == 0) && (now - createtime <= FREE_LICENSE)) {
return 0;
}
}
ret = license_check(gloconf.home, &capacity, free_limit);
if (ret) {
if (ret == ENOENT) {
if (now - createtime > FREE_LICENSE) {
DERROR("No license found.\n");
}
else
return 0;
} else if (ret == ETIME) {
DERROR("License expired.\n");
} else if (ret == ENOSPC) {
DERROR("Excess capacity.\n");
} else {
DERROR("Invalid license.\n");
}
exit(EACCES);
}
return 0;
err_ret:
return ret;
}
/* mark interrupt slot as unused, close descriptor if all slots are unused */
void _smi_free_int_scidesc(smi_sci_desc_t* pDesc, sci_error_t* pError)
{
smi_sci_desc_list_t* pTemp;
SMI_LOCK(&sdMutex);
pTemp = **pDesc;
switch(pTemp->ltype) {
case sd_rmtlocfree:
/* descriptor becomes unused => will be completely removed */
sd_node_remove(*pDesc);
rs_SCIClose(pTemp->sd,0,pError);
free(pTemp);
break;
case sd_locintfree:
case sd_rmtintfree:
case sd_intfree:
DERROR("internal list-structure error");
SMI_Abort(-1);
break;
case sd_full:
/* descriptor now has a free interrupt slot */
sd_node_remove(*pDesc);
pTemp->ltype = sd_intfree;
pTemp->pIntRef = NULL;
sd_node_push_front(&pIntListRoot, pTemp);
*pError = SCI_ERR_OK;
break;
case sd_locfree:
/* descriptor now has a free interrupt and local slot */
sd_node_remove(*pDesc);
pTemp->ltype = sd_locintfree;
pTemp->pIntRef = NULL;
sd_node_push_front(&pLocIntListRoot, pTemp);
*pError = SCI_ERR_OK;
break;
case sd_rmtfree:
/* descriptor now has a free interrupt and remote slot */
sd_node_remove(*pDesc);
pTemp->ltype = sd_rmtintfree;
pTemp->pIntRef = NULL;
sd_node_push_front(&pRmtIntListRoot, pTemp);
*pError = SCI_ERR_OK;
break;
default:
DERROR("internal list-structure error (invalid type)");
SMI_Abort(-1);
}
/* invalidate the given descriptor */
*pDesc = NULL;
SMI_UNLOCK(&sdMutex);
}
/**
* @brief SD card write function with scatter list.
* @param sd[in]: Card information.
* @param sector[in]: Start sector.
* @param sg[in]: Scatter list pointer.
* @param ln[in]: List number.
* @return Actual sectors by reading/ERROR_ID(<0).
*/
int gp_sdcard_write_scatter(gpSDInfo_t * sd, unsigned int sector, struct scatterlist *sg, unsigned int ln)
{
int i;
struct scatterlist *sg_ev;
int ret = 0;
int sector_num = 0;
#ifdef USE_DMA
unsigned sgln;
sgln = dma_map_sg(NULL, sg, ln, DMA_TO_DEVICE);
if(sgln!=ln)
{
dma_unmap_sg(NULL, sg, sgln, DMA_TO_DEVICE);
DERROR("[%d]: SG map fail, sgln = %d, ln = %d\n", sd->device_id, sgln, ln);
return -ENOMEM;
}
#endif
if(gp_sdcard_writecmd(sd->device_id,sector)==SP_FALSE)
{
ret = -EIO;
goto out_error;
}
DEBUG("SD: write sector %d\n", sector);
for_each_sg(sg, sg_ev, ln, i)
{
unsigned int number = sg_dma_len(sg_ev)>>9;
/* ----- Start dma ----- */
#ifdef USE_DMA
if(gp_sdcard_dma_en(sd->device_id, (unsigned char*)sg_phys(sg_ev), sg_dma_len(sg_ev),1)==SP_FALSE)
#else
if(gp_sdcard_dma_en(sd->device_id, (unsigned char*)sg_virt(sg_ev), sg_dma_len(sg_ev),1)==SP_FALSE)
#endif
{
ret = -ENOMEM;
DERROR("[%d]:DMA Enable error\n", sd->device_id);
goto out_error;
}
/* ----- Wait dma finish ----- */
ret = gp_sdcard_dma_finish(sd->device_id, (sg_dma_len(sg_ev)>>9)*WRITE_TIMEOUT);
if(ret!=0)
{
gp_apbdma0_stop(sd->handle_dma);
DERROR("[%d]:DMA error: %d, SD status 0x%x\n", sd->device_id, ret,gpHalSDGetStatus(sd->device_id));
goto out_error;
}
#ifdef USE_DMA
if(gpHalSDWaitDataComplete(sd->device_id) == SP_FALSE)
{
DERROR("[%d]: wait complete error: SD status 0x%x\n", sd->device_id, gpHalSDGetStatus(sd->device_id));
ret = -ETIMEDOUT;
goto out_error;
}
#endif
sector_num += number;
}
int
master_init(int voteid, char *data, int datalen)
{
int ret;
WThread *wt = g_runtime->wthread;
wt->clog = commitlog_create();
g_cf->role = ROLE_MASTER;
wt->backup_info = (BackupInfo *)zz_malloc(sizeof(BackupInfo));
DNOTE("============I am the master\n");
if (wt->backup_info == NULL) {
DERROR("malloc BackupInfo struct error\n");
MEMLINK_EXIT;
}
memset(wt->backup_info, 0x0, sizeof(BackupInfo));
BackupInfo *binfo = wt->backup_info;
g_runtime->servernums = 1;
g_runtime->voteid = voteid;
binfo->timer_send = FALSE;
int count = 0;
char ip[16] = {0};
uint16_t port;
DINFO("datalen : %d\n", datalen);
while (count < datalen) {
ret = unpack_votehost(data + count, ip, &port);
DINFO("ip: %s port: %d\n", ip, port);
count += ret;
BackupItem *bitem = (BackupItem *)zz_malloc(sizeof(BackupItem));
if (bitem == NULL) {
DERROR("malloc BackupItem struct error\n");
MEMLINK_EXIT;
}
memset(bitem, 0x0, sizeof(BackupItem));
strcpy(bitem->ip, ip);
bitem->write_port = port;
DINFO("backup ip, port: %s:%d\n", ip, port);
bitem->next = binfo->item;
binfo->item = bitem;
g_runtime->servernums++;
}
master_create_heartbeat(wt);
//初始化backupinfo结构
ret = master_connect_backup_all(wt);
return 0;
}
int test_move(TestArgs *args)
{
MemLink *m;
int ret, i;
char value[512] = {0};
int valint = atoi(args->value);
char format[64];
DINFO("====== move ======\n");
sprintf(format, "%%0%dd", args->valuesize);
if (args->longconn) {
m = memlink_create(args->host, args->rport, args->wport, args->timeout);
if (NULL == m) {
DERROR("memlink_create error!\n");
exit(-1);
return -1;
}
for (i = 0; i < args->testcount; i++) {
sprintf(value, format, valint);
ret = memlink_cmd_move(m, args->table, args->key, value, args->valuesize, args->pos);
if (ret != MEMLINK_OK) {
DERROR("move error! ret:%d, table:%s key:%s,value:%s,pos:%d\n",
ret, args->table, args->key, value, args->pos);
return -2;
}
valint++;
}
memlink_destroy(m);
} else {
for (i = 0; i < args->testcount; i++) {
m = memlink_create(args->host, args->rport, args->wport, args->timeout);
if (NULL == m) {
DERROR("memlink_create error!\n");
exit(-1);
return -1;
}
sprintf(value, format, valint);
ret = memlink_cmd_move(m, args->table, args->key, value, args->valuesize, args->pos);
if (ret != MEMLINK_OK) {
DERROR("move error! ret:%d, table:%s key:%s,value:%s,pos:%d\n",
ret, args->table, args->key, value, args->pos);
return -2;
}
valint++;
memlink_destroy(m);
}
}
return 0;
}
void
vote_destroy(Conn *conn)
{
VoteConn *vconn = (VoteConn *)conn;
if (conn->rbuf)
zz_free(conn->rbuf);
event_del(&conn->evt);
set_linger(conn->sock);
close(conn->sock);
if (vconn->vote_status == VOTE_TIMEOUT) {
DERROR("*** VOTE TIMEOUT, TRY AGAIN\n");
vconn->vote_status = VOTE_CONTINUE;
} else if (vconn->vote_status == VOTE_REQUEST || vconn->vote_status == VOTE_WAITING) {
/*
if (g_cf->role == ROLE_NONE) {
DERROR("*** VOTE REQUEST TRY AGAIN\n");
vconn->status = VOTE_CONTINUE;
} else {
*/
DERROR("*** VOTE ABNORMAL ERROR/HOST INVALID\n");
vconn->vote_status = VOTE_CONTINUE;
/*
g_cf->role = ROLE_NONE;
g_runtime->voteid = 0;
zz_free(vconn);
return;
}
*/
} else if (vconn->vote_status == VOTE_ERR_PARAM) {
DERROR("*** VOTE PARAM ERROR\n");
g_cf->role = ROLE_NONE;
g_runtime->voteid = 0;
zz_free(vconn);
return;
}
if (vconn->vote_status == VOTE_CONTINUE) {
DINFO("*** VOTE CONTINUE\n");
request_vote(vconn->id, vconn->idflag, vconn->voteid, vconn->wport);
zz_free(vconn);
return;
}
DINFO("*** VOTE OK\n");
zz_free(vconn);
}
int main(int argc, char **argv)
{
#ifdef DEBUG
logfile_create("test.log", 3);
#endif
char *conffile = "memlink.conf";
MemPool *mp;
MemItem *item_100;
MemItem *item_10;
myconfig_create(conffile);
my_runtime_create_common("memlink");
mp = g_runtime->mpool;
item_100 = (MemItem *)zz_malloc(sizeof(MemItem));
memset(item_100, 0x0, sizeof(MemItem));
item_10 = (MemItem *)zz_malloc(sizeof(MemItem));
memset(item_10, 0x0, sizeof(MemItem));
DataBlock *dbk;
int i;
for (i = 0; i < 100; i++) {
dbk = mempool_get(mp, 100 + sizeof(DataBlock));
dbk->next = item_100->data;
item_100->data = dbk;
}
for (i = 0; i < mp->used; i++) {
if (mp->freemem[i].memsize == 100 + sizeof(DataBlock)) {
break;
}
}
if (i == mp->used) {
DERROR("i == mp->used\n");
return -1;
}
if (mp->freemem[i].total != 100) {
DERROR("mp->freemem[i].total != 100\n");
return -1;
}
if (mp->freemem[i].block_count != 0) {
DERROR("mp->freemem[i].block_count != 0\n");
return -1;
}
return 0;
}
int
tcp_socket_server(char *host, int port)
{
int fd;
int ret;
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
char errbuf[1024];
strerror_r(errno, errbuf, 1024);
DERROR("create socket error: %s\n", errbuf);
return -1;
}
tcp_server_setopt(fd);
struct sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons((short)port);
if (host) {
sin.sin_addr.s_addr = inet_addr(host);
}else{
sin.sin_addr.s_addr = htonl(INADDR_ANY);
}
memset(&(sin.sin_zero), 0, sizeof(sin.sin_zero));
DINFO("bind to: %d\n", port);
ret = bind(fd, (struct sockaddr*)&sin, sizeof(sin));
if (ret == -1) {
char errbuf[1024];
strerror_r(errno, errbuf, 1024);
DERROR("bind error: %s\n", errbuf);
close(fd);
return -1;
}
ret = listen(fd, 128);
if (ret == -1) {
char errbuf[1024];
strerror_r(errno, errbuf, 1024);
DERROR("listen error: %s\n", errbuf);
close(fd);
return -1;
}
return fd;
}
/**
* @brief SD polling stataus function when send command.
* @param device_id[in]: Index of SD controller.
* @param pollbit[in]: Polling status bit.
* @return SP_TRUE: success, SP_FALSE: timeout or status fail.
*/
static SP_BOOL WaitSDStatus(
UINT32 device_id,
UINT32 pollbit)
{
sdReg_t *psdReg = (sdReg_t*) SetSDBase(device_id);
UINT32 init = jiffies;
do
{
/* ----- SD status error ----- */
if (psdReg->sdStatus & (MASK_S_RespIdxError|MASK_S_RespCRCError|MASK_S_TimeOut))
{
DEBUG("cmd SD%d, CMD = 0x%x, STATUS = 0x%x\n", device_id, psdReg->sdCmd, psdReg->sdStatus);
return SP_FALSE;
}
/* ----- Timeout ----- */
if((jiffies-init)>=COMMAND_TIMEOUT)
{
DERROR("cmd SD%d timeout [t:%d], CMD = 0x%x, STATUS = 0x%x\n", device_id, (jiffies-init), psdReg->sdCmd, psdReg->sdStatus);
return SP_FALSE;
}
}while((psdReg->sdStatus & pollbit)!=pollbit);
return SP_TRUE;
}
/**
* @brief Check SD card status function by CMD13.
* @param sd[in]: Card information.
* @return SUCCESS/ERROR_ID.
*/
int gp_sdcard_get_status(gpSDInfo_t * sd)
{
unsigned int response = 0;
if(gpHalSDSendCmd(sd->device_id, SD_CMD13, sd->RCA, &response, 4)==SP_FALSE)
{
DERROR("[%d]: CMD13 fail\n", sd->device_id);
return -EIO;
}
/* ----- Check response error bit ----- */
if(gp_sdcard_ch_resp(response))
{
DERROR("[%d]: resp = %d error\n", response );
return -EINVAL;
}
return 0;
}
bool ProgramState::dumpToFile()
{
if(!runningDump())
{
DERROR("not running dump");
return false;
}
Wav w;
w.make(wavdump->getBytes(),dumpoff*2 /*bytes*/,getSampleRate(),nchan,16);
string fname = running_dump_name;
DASSERT(fname.size()>0);
w.save(fname,true);
cout << "wrote: " << fname.c_str() << endl;
w.del();
delete wavdump;
wavdump=NULL;
dumplen=0;
return true;
}
/**
* @brief Scatter list data transfer function.
* @param sd[in]: Card information.
* @param sector[in]: Start sector.
* @param sg[in]: Scatter list pointer.
* @param ln[in]: List number.
* @return Actual sectors by reading/ERROR_ID(<0).
*/
static int gp_sdcard_transfer_scatter(gpSDInfo_t *sd, unsigned long sector, struct scatterlist *sg, unsigned int ln, int write)
{
int ret;
int pin_handle;
/* ----- Check card status ----- */
if((gp_sdcard_ckinsert(sd)==0)||(sd->handle_dma==0))
return -ENXIO;
/* ----- Get pin handle ----- */
pin_handle = gp_board_pin_func_request((sd->device_id==0)?GP_PIN_SD0:GP_PIN_SD1, GP_BOARD_WAIT_FOREVER);
if(pin_handle<0)
{
DERROR("SD%d: can't get pin handle\n", sd->device_id);
return -EIO;
}
if(write==0)
{
ret = gp_sdcard_read_scatter(sd, sector, sg, ln);
}
else
{
/* ----- Check write protect ----- */
if(sd->sd_func->is_write_protected()==1)
ret = -EROFS;
else
ret = gp_sdcard_write_scatter(sd, sector, sg, ln);
}
gp_board_pin_func_release(pin_handle);
return ret;
}
// execute dialog in a child process, leave it running
///////////////////////////////////////////////////////////////////////////////////////////
pid_t sdialog_call(const char *path, const char *msg, const char *pinName) {
pid_t pid;
dlg_log_printf("sdialog_call/fork\n");
if ((pid = fork()) < 0) {
dlg_log_error("sdialog_call/fork");
return 0L;
}
if (pid == 0) {
char *disp = getenv("DISPLAY");
dlg_log_printf("sdialog_call: in child\n");
if (disp != NULL) {
DPRINTF("sdialog_call: DISPLAY=%s\n", disp);
} else {
DPRINTF("DISPLAY not set\n");
}
umask(0);
chdir("/");
DPRINTF("call_dialog: about to exec %s\n", path);
execlp(path, path, pinName, msg, (char *) 0);
DERROR("sdialog_call/execlp");
exit(1);
}
dlg_log_printf("sdialog_call: child PID=%d\n", pid);
return pid;
}
bool CSTi7108MainOutput::ShowPlane(stm_plane_id_t planeID)
{
DEBUGF2(2,("CSTi7108MainOutput::ShowPlane %d\n",(int)planeID));
stm_clk_divider_output_divide_t div;
if(!m_pClkDivider->getDivide(STM_CLK_DISP_HD,&div))
{
DERROR("Cannot get display clock divider\n");
return false;
}
if(planeID == OUTPUT_GDP1)
{
m_pClkDivider->Enable(STM_CLK_GDP1, STM_CLK_SRC_0, div);
DEBUGF2(2,("%s: GDP1 clock set to HD disp clock\n",__PRETTY_FUNCTION__));
}
else if(planeID == OUTPUT_GDP2)
{
m_pClkDivider->Enable(STM_CLK_GDP2, STM_CLK_SRC_0, div);
DEBUGF2(2,("%s: GDP2 clock set to HD disp clock\n",__PRETTY_FUNCTION__));
}
else if (planeID == OUTPUT_VID1)
{
ULONG val = ReadSysCfgReg(SYS_CFG2) | SYS_CFG2_PIP_MODE;
WriteSysCfgReg(SYS_CFG2,val);
m_pClkDivider->Enable(STM_CLK_DISP_PIP, STM_CLK_SRC_0, div);
DEBUGF2(2,("%s: PIP clock set to HD disp clock\n",__PRETTY_FUNCTION__));
}
return CSTmMasterOutput::m_pMixer->EnablePlane(planeID);
}
bool Connection::removeLine(LineData* line)
{
con_list_it t = find(lines.begin(),lines.end(), line);
if(t==lines.end())
{
DERROR("(W) line not found");
return false;
}
LineData* ld = *t;
lines.erase(t);
DASSERT(ld!=NULL);
DASSERT(ld->in!=NULL && ld->out!=NULL);
//tell the soundcomps to remove this input/output pair
ld->in->remInput();
ld->out->remOutput();
//MUST remove link to line in it/og from
ld->in->remLine();
ld->out->remLine();
delete ld;
return true;
}
DSocket* d_socket_connect_by_ip(char* ip, int port, DError** error) {
int iResult;
WSADATA wsaData;
// Initialize Winsock
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (iResult != 0) {
printf("WSAStartup failed: %d\n", iResult);
return NULL;
}
DSocket* new_socket = d_malloc(sizeof (DSocket));
struct sockaddr_in sock_adress;
if ((sock_adress.sin_addr.s_addr = inet_addr(ip)) == -1) {
if (error)
*error = DERROR("IP adress %s is invalid", ip);
goto error;
};
sock_adress.sin_family = AF_INET; /* Protocol IP */
sock_adress.sin_port = htons(port);
new_socket->socket_desc = socket(AF_INET, SOCK_STREAM, 0);
if (new_socket->socket_desc == INVALID_SOCKET) {
if (error)
*error = DERROR("Cant create socket, %s", strerror(errno));
goto error;
}
if (connect(new_socket->socket_desc, (const struct sockaddr*) &sock_adress, sizeof (sock_adress)) == SOCKET_ERROR) {
if (error)
*error = DERROR("Connection to %s:%d failed, %s", ip, port, strerror(errno));
goto error;
}
return new_socket;
error:
if (new_socket) d_socket_close(new_socket);
return NULL;
}
/*
* Function irnet_find_lsap_sel (self)
*
* Try to lookup LSAP selector in remote LM-IAS
*
* Basically, we start a IAP query, and then go to sleep. When the query
* return, irnet_getvalue_confirm will wake us up, and we can examine the
* result of the query...
* Note that in some case, the query fail even before we go to sleep,
* creating some races...
*/
static int
irnet_find_lsap_sel(irnet_socket * self)
{
DENTER(IRDA_SR_TRACE, "(self=0x%X)\n", (unsigned int) self);
/* This should not happen */
DABORT(self->iriap, -EBUSY, IRDA_SR_ERROR, "busy with a previous query.\n");
/* Create an IAP instance, will be closed in irnet_getvalue_confirm() */
self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
irnet_getvalue_confirm);
/* Treat unexpected signals as disconnect */
self->errno = -EHOSTUNREACH;
/* Query remote LM-IAS */
iriap_getvaluebyclass_request(self->iriap, self->saddr, self->daddr,
IRNET_SERVICE_NAME, IRNET_IAS_VALUE);
/* Wait for answer (if not already failed) */
if(self->iriap != NULL)
interruptible_sleep_on(&self->query_wait);
/* Check what happened */
if(self->errno)
{
DEBUG(IRDA_SR_INFO, "IAS query failed! (%d)\n", self->errno);
/* Requested object/attribute doesn't exist */
if((self->errno == IAS_CLASS_UNKNOWN) ||
(self->errno == IAS_ATTRIB_UNKNOWN))
return (-EADDRNOTAVAIL);
else
return (-EHOSTUNREACH);
}
/* Get the remote TSAP selector */
switch(self->ias_result->type)
{
case IAS_INTEGER:
DEBUG(IRDA_SR_INFO, "result=%d\n", self->ias_result->t.integer);
if(self->ias_result->t.integer != -1)
self->dtsap_sel = self->ias_result->t.integer;
else
self->dtsap_sel = 0;
break;
default:
self->dtsap_sel = 0;
DERROR(IRDA_SR_ERROR, "bad type ! (0x%X)\n", self->ias_result->type);
break;
}
/* Cleanup */
if(self->ias_result)
irias_delete_value(self->ias_result);
DEXIT(IRDA_SR_TRACE, "\n");
if(self->dtsap_sel)
return 0;
return -EADDRNOTAVAIL;
}
int
timeout_wait(int fd, int timeout, int writing)
{
if (timeout <= 0) {
// return TRUE; // true
timeout = 0;
}
if (fd < 0) {
DERROR("timeout_wait fd error: %d\n", fd);
return FALSE; //error
}
// second to millisecond
timeout = timeout * 1000;
struct pollfd fds[1];
int ret;
//struct timeval start, end;
fds[0].fd = fd;
while (1) {
//gettimeofday(&start, NULL);
if (writing)
fds[0].events = POLLOUT;
else
fds[0].events = POLLIN;
ret = poll(fds, 1, timeout);
//DINFO("poll:%d\n", ret);
if (ret < 0) {
if (errno == EINTR) {
/*gettimeofday(&end, NULL);
unsigned int td = timediff(&start, &end);
timeout -= td / 1000;
if (timeout <= 0)
return FALSE;*/
continue;
}
char errbuf[1024];
strerror_r(errno, errbuf, 1024);
DWARNING("timeout_wait poll error: %d, %s\n", fds[0].fd, errbuf);
return FALSE;
}
break;
}
/*DINFO("poll %x in:%d, out:%d, err:%d, hup:%d\n", fds[0].revents,
fds[0].revents & POLLIN, fds[0].revents & POLLOUT,
fds[0].revents & POLLERR, fds[0].revents & POLLHUP);*/
if ((fds[0].revents & POLLOUT) && writing)
return TRUE;
if ((fds[0].revents & POLLIN) && !writing)
return TRUE;
if ((fds[0].revents & POLLHUP) | (fds[0].revents & POLLERR))
return ERROR;
return ERROR;
}
void GOctScale::setState(SoundCompEvent* e)
{
DASSERT(e!=NULL);
if(e->empty())return;
if(e->getSize()!=sizeof(State))
{
DERROR("size missmatch");
if(e->getSize() < sizeof(State))return;
DERROR("trying to read...");
}
const State* s = (const State*)e->getData();
ns->setValue(s->noct);
update();
}
void GAbs::setState(SoundCompEvent* e)
{
DASSERT(e!=NULL);
if(e->empty())return;
if(e->getSize()!=sizeof(State))
{
DERROR("size missmatch");
if(e->getSize() < sizeof(State))return;
DERROR("trying to read...");
}
const State* s = (const State*)e->getData();
b_mode->setValue(s->mode);
sig->setHalf(b_mode->getValue());
}
/**
* attr必须先初始化为0
*/
int
attr_array2binary(uint8_t *attrformat, uint32_t *attrarray, char attrnum, char *attr)
{
int i;
int b = 0; // 已经处理的bit
int idx = 0;
int n;
uint32_t v, flow = 0;
char mf;
// 前两位分别表示真实删除和标记删除，跳过
// attr[idx] = attr[idx] & 0xfc;
//memset(attr, 0, attrnum);
attr[0] = 0x01; // 默认设置数据有效，非标记删除
b += 2;
for (i = 0; i < attrnum; i++) {
mf = attrformat[i];
if (mf == 0) {
DERROR("attr format error: %d\n", mf);
return -1;
}
v = attrarray[i];
//DINFO("idx:%d, b:%d, format:%d, attrvalue:%d, %x\n", idx, b, mf, v, v);
if (v == UINT_MAX) {
v = 0;
}
uint8_t y = (b + mf) % 8;
n = (b + mf) / 8 + (y>0 ? 1: 0);
if (n > 4) {
flow = v >> (32 - b);
}
v = v << b;
uint8_t m = 0xffffffff >> (32 - b);
uint8_t x = attr[idx] & m;
v = v | x;
if (n > 4) {
memcpy(&attr[idx], &v, sizeof(int));
} else {
memcpy(&attr[idx], &v, n);
}
if (y > 0) {
idx += n - 1;
}else{
idx += n;
}
if (n > 4) {
attr[idx] = attr[idx] | flow;
}
b = y;
//DINFO("============================\n");
}
