STATICFNDEF int4 bml_find_busy_recycled(int4 hint, uchar_ptr_t base_addr, int4 blks_in_lmap, int *bml_status_ptr)
{
uchar_ptr_t ptr, top;
int status;
int4 base_blk, blknum, i;
top = base_addr + DIVIDE_ROUND_UP(blks_in_lmap, BML_BLKS_PER_UCHAR);
for (ptr = base_addr + DIVIDE_ROUND_DOWN(hint, BML_BLKS_PER_UCHAR); ptr < top; ptr++)
{
if (FOUR_BLKS_FREE == *ptr)
continue;
base_blk = (int4)((ptr - base_addr) * (8 / BML_BITS_PER_BLK));
/* loop through 4 blocks corresponding to this byte */
for (i = 0; i < BML_BLKS_PER_UCHAR; i++)
{
blknum = i + base_blk;
if (blknum < hint || blks_in_lmap <= blknum)
continue;
GET_STATUS(*ptr, i, status);
if (status != BLK_FREE)
{
assert((t_tries < CDB_STAGNATE) || (status == BLK_BUSY) || (status == BLK_RECYCLED));
*bml_status_ptr = status;
return blknum;
}
}
}
return -1;
}
static void pollSDO(void)
{
// wait until SDO goes high
while (0 == GET_STATUS(COIO_SDO_CFG))
{
}
}
int serial_getchar(void)
{
unsigned int Status;
unsigned int Ch;
Ch=0;
//Ch = lib_support_getchar();
if (Ch == 0)
{
#if defined(SEMIHOSTED)
// Use the debugger if the ports are the same
if (HOST_COMPORT == OS_COMPORT)
Ch = (int)SWI_READC();
else
#endif
{
do
{
Status = GET_STATUS(OS_COMPORT);
}
while (!RX_DATA(Status)); // wait until ready
Ch = GET_CHAR(OS_COMPORT);
}
}
return ((int)Ch);
}
static int
cyg_hal_plf_serial_isr(void *__ch_data, int* __ctrlc,
CYG_ADDRWORD __vector, CYG_ADDRWORD __data)
{
int res = 0;
channel_data_t* chan = (channel_data_t*)__ch_data;
char c;
cyg_uint32 status;
CYGARC_HAL_SAVE_GP();
cyg_drv_interrupt_acknowledge(chan->isr_vector);
*__ctrlc = 0;
status = GET_STATUS(chan->base);
if ( RX_DATA(status) ) {
c = GET_CHAR(chan->base);
if( cyg_hal_is_break( &c , 1 ) )
*__ctrlc = 1;
res = CYG_ISR_HANDLED;
}
CYGARC_HAL_RESTORE_GP();
return res;
}
/**
* Function: module_imgbase_port_check_caps_unreserve
*
* Description: This method is used to unreserve the port
*
* Arguments:
* @identity: identitity for the session and stream
* @port: mct port pointer
* @peer: peer mct port pointer
*
* Return values:
* error/success
*
* Notes: none
**/
boolean module_imgbase_port_check_caps_unreserve(mct_port_t *port,
unsigned int identity)
{
int rc = IMG_SUCCESS;
mct_module_t *p_mct_mod = NULL;
module_imgbase_t *p_mod = NULL;
imgbase_client_t *p_client = NULL;
uint32_t *p_identity = NULL;
if (!port) {
IDBG_ERROR("%s:%d invalid input", __func__, __LINE__);
return FALSE;
}
IDBG_MED("%s:%d] E %d", __func__, __LINE__, MCT_PORT_DIRECTION(port));
p_mct_mod = MCT_MODULE_CAST((MCT_PORT_PARENT(port))->data);
if (!p_mct_mod) {
IDBG_ERROR("%s:%d invalid module", __func__, __LINE__);
return FALSE;
}
p_mod = (module_imgbase_t *)p_mct_mod->module_private;
if (NULL == p_mod) {
IDBG_ERROR("%s:%d] imgbase module NULL", __func__, __LINE__);
return FALSE;
}
p_client = (imgbase_client_t *)port->port_private;
if (NULL == p_client) {
IDBG_ERROR("%s:%d] imgbase client NULL", __func__, __LINE__);
return FALSE;
}
/* lock the module */
pthread_mutex_lock(&p_mod->mutex);
if (MCT_PORT_IS_SRC(port)) {
port->port_private = NULL;
} else {
module_imgbase_port_release_client(p_mod, port, p_client, identity);
port->port_private = NULL;
if (p_mod->subdevfd >= 0) {
close(p_mod->subdevfd);
p_mod->subdevfd = -1;
}
}
pthread_mutex_unlock(&p_mod->mutex);
/*Todo: free port??*/
IDBG_MED("%s:%d] X", __func__, __LINE__);
return GET_STATUS(rc);
error:
pthread_mutex_unlock(&p_mod->mutex);
IDBG_MED("%s:%d] Error rc = %d X", __func__, __LINE__, rc);
return FALSE;
}
/*
* Interrupts on.
*/
void
cpu_irqon(void)
{
uint32_t x;
GET_STATUS(x);
x |= CST_IEc;
SET_STATUS(x);
}
/*
* Interrupts off.
*/
void
cpu_irqoff(void)
{
uint32_t x;
GET_STATUS(x);
x &= ~(uint32_t)CST_IEc;
SET_STATUS(x);
}
/**
* Function: module_imgbase_port_ext_link
*
* Description: This method is called when the user establishes
* link.
*
* Arguments:
* @identity: identitity for the session and stream
* @port: mct port pointer
* @peer: peer mct port pointer
*
* Return values:
* error/success
*
* Notes: none
**/
boolean module_imgbase_port_ext_link(unsigned int identity,
mct_port_t* port, mct_port_t *peer)
{
int rc = IMG_SUCCESS;
unsigned int *p_identity = NULL;
mct_list_t *p_temp_list = NULL;
mct_module_t *p_mct_mod = NULL;
module_imgbase_t *p_mod = NULL;
imgbase_client_t *p_client = NULL;
if (!port || !peer) {
IDBG_ERROR("%s:%d invalid input", __func__, __LINE__);
return FALSE;
}
IDBG_MED("%s:%d] port %p E", __func__, __LINE__, port);
p_mct_mod = MCT_MODULE_CAST((MCT_PORT_PARENT(port))->data);
if (!p_mct_mod) {
IDBG_ERROR("%s:%d invalid module", __func__, __LINE__);
return FALSE;
}
p_mod = (module_imgbase_t *)p_mct_mod->module_private;
if (NULL == p_mod) {
IDBG_ERROR("%s:%d] imgbase module NULL", __func__, __LINE__);
return FALSE;
}
p_client = (imgbase_client_t *)port->port_private;
if (NULL == p_client) {
IDBG_ERROR("%s:%d] invalid client", __func__, __LINE__);
return FALSE;
}
if (MCT_PORT_PEER(port)) {
IDBG_ERROR("%s:%d] link already established", __func__, __LINE__);
return FALSE;
}
MCT_PORT_PEER(port) = peer;
/* check if its sink port*/
if (MCT_PORT_IS_SINK(port)) {
/* start imgbase client in case of dynamic module */
} else {
/* do nothing for source port */
}
IDBG_MED("%s:%d] X", __func__, __LINE__);
return GET_STATUS(rc);
error:
IDBG_MED("%s:%d] Error X", __func__, __LINE__);
return FALSE;
}
/**
* Function: module_imgbase_port_acquire
*
* Description: This function is used to acquire the port
*
* Arguments:
* @p_mct_mod: mct module pointer
* @port: mct port pointer
* @stream_info: stream information
*
* Return values:
* true/false
*
* Notes: none
**/
boolean module_imgbase_port_acquire(mct_module_t *p_mct_mod,
mct_port_t *port,
mct_stream_info_t *stream_info)
{
int rc = IMG_SUCCESS;
unsigned int p_identity ;
mct_list_t *p_temp_list = NULL;
imgbase_client_t *p_client = NULL;
module_imgbase_t *p_mod = NULL;
IDBG_MED("%s:%d] E", __func__, __LINE__);
p_mod = (module_imgbase_t *)p_mct_mod->module_private;
if (NULL == p_mod) {
IDBG_ERROR("%s:%d] imgbase module NULL", __func__, __LINE__);
return FALSE;
}
p_identity = stream_info->identity;
/* check if its sink port*/
if (MCT_PORT_IS_SINK(port)) {
rc = module_imglib_common_get_bfr_mngr_subdev(&p_mod->subdevfd);
if (!rc || p_mod->subdevfd < 0) {
IDBG_ERROR("%s:%d] Error rc %d fd %d", __func__, __LINE__, rc,
p_mod->subdevfd);
goto error;
}
/* create imgbase client */
rc = module_imgbase_client_create(p_mct_mod, port, p_identity, stream_info);
} else {
/* update the internal connection with source port */
p_temp_list = mct_list_find_custom(p_mod->imgbase_client, &p_identity,
module_imgbase_find_client);
if (NULL != p_temp_list) {
p_client = p_temp_list->data;
p_client->p_srcport = port;
port->port_private = p_client;
IDBG_MED("%s:%d] found client %p", __func__, __LINE__, p_client);
} else {
IDBG_ERROR("%s:%d] cannot find the client", __func__, __LINE__);
goto error;
}
}
IDBG_MED("%s:%d] port %p port_private %p X", __func__, __LINE__,
port, port->port_private);
return GET_STATUS(rc);
error:
IDBG_MED("%s:%d] Error X", __func__, __LINE__);
return FALSE;
}
static tU08 transferByte_U08(tU08 data_U08, tU08 instruction_U08)
{
tU08 i_U08;
tU08 byteRead_U08 = 0;
/* first bit is zero */
SDI_LO;
SII_LO;
clockit();
for (i_U08 = 0; i_U08 < 8; i_U08++)
{
/* read one bit form SDO */
byteRead_U08 <<= 1; // shift one bit, this clears LSB
if (GET_STATUS(COIO_SDO_CFG) != 0)
{
byteRead_U08 |= 1;
}
/* output next data bit on SDI */
if (data_U08 & 0x80)
{
SDI_HI;
}
else
{
SDI_LO;
}
/* output next instruction bit on SII */
if (instruction_U08 & 0x80)
{
SII_HI;
}
else
{
SII_LO;
}
clockit();
/* prepare for processing next bit */
data_U08 <<= 1;
instruction_U08 <<= 1;
}
/* Last two bits are zero */
SDI_LO;
SII_LO;
clockit();
clockit();
return byteRead_U08;
}
int putchar_uart0(int ch)
{
/* Place your implementation of fputc here */
/* e.g. write a character to a UART, or to the */
/* debugger console with SWI WriteC */
while ( TX_READY(GET_STATUS(UART0_BASE))==0);
PUT_CHAR(UART0_BASE, ch);
return ch;
}
/*
* Used below.
*/
static
void
cpu_irqonoff(void)
{
uint32_t x, xon, xoff;
GET_STATUS(x);
xon = x | CST_IEc;
xoff = x & ~(uint32_t)CST_IEc;
SET_STATUS(xon);
__asm volatile("nop; nop; nop; nop");
SET_STATUS(xoff);
}
void sendchar( char *ch )
{
char Ch;
unsigned int Status;
Ch=*ch;
do
{
Status = GET_STATUS(OS_COMPORT);
}
while (!TX_READY(Status)); // wait until ready
PUT_CHAR(OS_COMPORT, Ch);
if (Ch == '\n')
{
do
{
Status = GET_STATUS(OS_COMPORT);
}
while (!TX_READY(Status)); // wait until ready
PUT_CHAR(OS_COMPORT, '\r');
}
}
void
cyg_hal_plf_serial_putc(void *__ch_data, char c)
{
channel_data_t* chan = (channel_data_t*)__ch_data;
cyg_uint8* base = chan->base;
cyg_uint32 status;
CYGARC_HAL_SAVE_GP();
do {
status = GET_STATUS(base);
} while (!TX_READY(status)); // wait until ready
PUT_CHAR(base, c);
if (c == '\n') {
do {
status = GET_STATUS(base);
} while (!TX_READY(status)); // wait until ready
PUT_CHAR(base, '\r');
}
CYGARC_HAL_RESTORE_GP();
}
static cyg_bool
cyg_hal_plf_serial_getc_nonblock(void* __ch_data, cyg_uint8* ch)
{
cyg_uint8* base = ((channel_data_t*)__ch_data)->base;
cyg_uint32 status ;
long timeout = 100; // A long time...
do {
status = GET_STATUS(base);
if (--timeout == 0) return false ;
} while (!RX_DATA(status)); // wait until ready
*ch = GET_CHAR(base);
return true;
}
// Executes a <simple> redirection. If background == true, the command is
// executed in the background. Returns the <simple>'s status, or 0 if background
// is true and we don't wait for it to die.
int processSimple(CMD* cmd, bool background)
{
if(IS_BUILTIN(cmd->argv[0]))
{
int status = execBuiltin(cmd);
updateStatusVar(status);
return status;
}
int pid;
if((pid = fork()) < 0)
{
// error in forking
perror(EXEC_NAME);
return errno;
}
else if(pid == 0)
{
// child
if(redirect(cmd) < 0)
{
exit(errno);
}
execvp(cmd->argv[0], cmd->argv);
perror(EXEC_NAME);
exit(EXIT_FAILURE);
}
else
{
// parent
if(background)
{
return 0;
}
else
{
int status;
signal(SIGINT, SIG_IGN);
waitpid(pid, &status, 0);
signal(SIGINT, SIG_DFL);
int exitStatus = GET_STATUS(status);
updateStatusVar(exitStatus);
return exitStatus;
}
}
}
/*
* Check if transaction must block.
*/
static inline int stm_check_quiesce(stm_tx_t *tx)
{
stm_word_t s;
/* Must be called upon start (while already active but before acquiring any lock) */
assert(IS_ACTIVE(tx->status));
ATOMIC_MB_FULL;
if (ATOMIC_LOAD_ACQ(&quiesce) == 2) {
s = ATOMIC_LOAD(&tx->status);
SET_STATUS(tx->status, TX_IDLE);
while (ATOMIC_LOAD_ACQ(&quiesce) == 2) {
sched_yield();
}
SET_STATUS(tx->status, GET_STATUS(s));
return 1;
}
return 0;
}
/**
* Function: module_imgbase_stop_session
*
* Description: This function is called when the camera
* session is stopped
*
* Arguments:
* @module: mct module pointer
* @sessionid: session id
*
* Return values:
* error/success
*
* Notes: none
**/
static boolean module_imgbase_stop_session(mct_module_t *module,
unsigned int sessionid)
{
int rc = IMG_SUCCESS;
module_imgbase_t *p_mod;
if (!module) {
IDBG_ERROR("%s:%d failed", __func__, __LINE__);
return FALSE;
}
p_mod = (module_imgbase_t *)module->module_private;
if (!p_mod) {
IDBG_ERROR("%s:%d failed", __func__, __LINE__);
return FALSE;
}
/* destroy message thread */
rc = module_imglib_destroy_msg_thread(&p_mod->msg_thread);
return GET_STATUS(rc);
}
int serial_kbhit(void)
{
unsigned int Status;
#if defined(SEMIHOSTED)
// If the ports are the same, have to use the debugger and we
// can't tell if there is a character available
if (HOST_COMPORT == OS_COMPORT)
{
return (1);
}
#endif
//lib_flush_buffer();
Status = GET_STATUS(0xFFF80000);
if (!RX_DATA(Status))
return (0);
else
return (1);
}
// Creates a subshell and executes cmd in it. Returns the status of the
// subcommand. If backgrond == true, the subcommand is executed in the
// background. The redirection info in subcmdNode is applied to the subshell if
// it is non-NULL.
int processSubcommand(CMD* cmd, CMD* subcmdNode, bool background)
{
int pid;
if((pid = fork()) < 0)
{
// error in forking
perror(EXEC_NAME);
return errno;
}
else if(pid == 0)
{
// child
if(subcmdNode && redirect(subcmdNode) < 0)
{
exit(errno);
}
exit(process(cmd));
}
else
{
// parent
if(background)
{
return 0;
}
else
{
int status;
signal(SIGINT, SIG_IGN);
waitpid(pid, &status, 0);
signal(SIGINT, SIG_DFL);
int exitStatus = GET_STATUS(status);
updateStatusVar(exitStatus);
return exitStatus;
}
}
}
/*
* Catch signal (to emulate non-faulting load).
*/
static void
signal_catcher(int sig)
{
sigset_t block_signal;
stm_tx_t *tx = tls_get_tx();
/* A fault might only occur upon a load concurrent with a free (read-after-free) */
PRINT_DEBUG("Caught signal: %d\n", sig);
/* TODO: TX_KILLED should be also allowed */
if (tx == NULL || tx->attr.no_retry || GET_STATUS(tx->status) != TX_ACTIVE) {
/* There is not much we can do: execution will restart at faulty load */
fprintf(stderr, "Error: invalid memory accessed and no longjmp destination\n");
exit(1);
}
/* Unblock the signal since there is no return to signal handler */
sigemptyset(&block_signal);
sigaddset(&block_signal, sig);
pthread_sigmask(SIG_UNBLOCK, &block_signal, NULL);
/* Will cause a longjmp */
stm_rollback(tx, STM_ABORT_SIGNAL);
}
/**
* Function: module_cac_port_event_func
*
* Description: Event handler function for the dummy port
*
* Arguments:
* @port: mct port pointer
* @event: mct event
*
* Return values:
* error/success
*
* Notes: none
**/
boolean module_cac_port_event_func(mct_port_t *port,
mct_event_t *event)
{
int rc = IMG_SUCCESS;
mct_module_t *p_mct_mod = NULL;
module_cac_t *p_mod = NULL;
cac_client_t *p_client;
boolean fwd_event = TRUE;
if (!port || !event) {
IDBG_ERROR("%s:%d invalid input", __func__, __LINE__);
return FALSE;
}
IDBG_LOW("%s:%d] port %p E", __func__, __LINE__, port);
p_mct_mod = MCT_MODULE_CAST((MCT_PORT_PARENT(port))->data);
if (!p_mct_mod) {
IDBG_ERROR("%s:%d invalid module", __func__, __LINE__);
return FALSE;
}
p_mod = (module_cac_t *)p_mct_mod->module_private;
if (NULL == p_mod) {
IDBG_ERROR("%s:%d] CAC module NULL", __func__, __LINE__);
return FALSE;
}
p_client = (cac_client_t *)port->port_private;
if (NULL == p_client) {
IDBG_ERROR("%s:%d] CAC client NULL", __func__, __LINE__);
return FALSE;
}
IDBG_LOW("%s:%d] type %d", __func__, __LINE__, event->type);
switch (event->type) {
case MCT_EVENT_CONTROL_CMD: {
mct_event_control_t *p_ctrl_event = &event->u.ctrl_event;
IDBG_MED("%s:%d] Ctrl type %d", __func__, __LINE__, p_ctrl_event->type);
switch (p_ctrl_event->type) {
case MCT_EVENT_CONTROL_STREAMON: {
IDBG_HIGH("%s:%d] CAC STREAMON", __func__, __LINE__);
pthread_mutex_lock(&p_client->mutex);
p_client->stream_off = FALSE;
pthread_mutex_unlock(&p_client->mutex);
break;
}
case MCT_EVENT_CONTROL_STREAMOFF: {
module_cac_t *p_mod = (module_cac_t *)p_client->p_mod;
IDBG_MED("%s:%d] CAC STREAMOFF", __func__, __LINE__);
pthread_mutex_lock(&p_client->mutex);
p_client->stream_off = TRUE;
pthread_mutex_unlock(&p_client->mutex);
img_q_flush(&p_mod->msg_thread.msg_q);
}
default:
break;
}
break;
}
case MCT_EVENT_MODULE_EVENT: {
mct_event_module_t *p_mod_event = &event->u.module_event;
img_component_ops_t *p_comp = &p_client->comp;
IDBG_MED("%s:%d] Mod type %d", __func__, __LINE__, p_mod_event->type);
switch (p_mod_event->type) {
case MCT_EVENT_MODULE_BUF_DIVERT: {
mod_img_msg_t msg;
isp_buf_divert_t *p_buf_divert =
(isp_buf_divert_t *)p_mod_event->module_event_data;
IDBG_ERROR("%s:%d] identity %x", __func__, __LINE__,
event->identity);
memset(&msg, 0x0, sizeof(mod_img_msg_t));
msg.port = port;
msg.type = MOD_IMG_MSG_DIVERT_BUF;
msg.data.buf_divert.buf_divert = *p_buf_divert;
msg.data.buf_divert.identity = p_client->identity;
msg.data.buf_divert.p_exec = module_cac_client_divert_exec;
msg.data.buf_divert.userdata = (void *)p_client;
module_imglib_send_msg(&p_mod->msg_thread, &msg);
/* indicate that the buffer is consumed */
p_buf_divert->is_locked = FALSE;
p_buf_divert->ack_flag = FALSE;
fwd_event = FALSE;
break;
}
case MCT_EVENT_MODULE_STATS_AWB_UPDATE: {
stats_update_t *stats_update = (stats_update_t *)
p_mod_event->module_event_data;
p_client->cac_cfg_info.cac_3a_data.awb_gr_gain =
FLOAT_TO_Q(7, stats_update->awb_update.gain.g_gain);
p_client->cac_cfg_info.cac_3a_data.awb_gb_gain =
FLOAT_TO_Q(7, stats_update->awb_update.gain.g_gain);
IDBG_HIGH("%s: abw gr = %f, awb gb = %f", __func__,
p_client->cac_cfg_info.cac_3a_data.awb_gr_gain,
p_client->cac_cfg_info.cac_3a_data.awb_gb_gain);
}
break;
case MCT_EVENT_MODULE_SET_CHROMATIX_PTR:
//Todo: Update chromatix params with Chromatix version 303
default:
break;
}
break;
}
default:
break;
}
if (fwd_event) {
boolean brc = module_cac_forward_port_event(p_client, port, event);
rc = (brc) ? IMG_SUCCESS : IMG_ERR_GENERAL;
}
return GET_STATUS(rc);
}
// Executes a pipeline and returns the exit status of the pipe. The arg
// pipeRoot is the PIPE or PIPE_ERR command at the root of the pipeline.
// This function draws upon code from Professor Stan Eisenstat at Yale
// University
int execPipe(CMD* pipeRoot)
{
// count the number of stages in the pipeline
int numStages = 1;
for(CMD* cmd = pipeRoot; ISPIPE(cmd->type); cmd = cmd->right, numStages++);
// create table to hold pid and exit status of all stages in the pipe
struct {
int pid, status;
} processTable[numStages];
int fd[2]; // holds file descriptors for the pipe
int pid, status; // the pid and status of a single stage
int fdIn = STDIN_FD; // the read end of the last pipe, or the original
// stdin
CMD* cmd = pipeRoot;
for(int i = 0; ISPIPE(cmd->type); cmd = cmd->right, i++)
{
if(pipe(fd) < 0 || (pid = fork()) < 0)
{
perror(EXEC_NAME);
return errno;
}
else if(pid == 0)
{
// child
close(fd[0]);
// redirect stdin to the last pipe read (if there was a last pipe)
if(fdIn != STDIN_FD)
{
dup2(fdIn, STDIN_FD);
close(fdIn);
}
bool shouldCloseFD1 = false;
// redirect stdout to the new pipe write (if it's not stdout)
if(fd[1] != STDOUT_FD)
{
dup2(fd[1], STDOUT_FD);
shouldCloseFD1 = true;
}
// if this is a PIPE_ERR, redirect stderr to the new pipe write
// (if it's not stderr)
if(cmd->type == PIPE_ERR && fd[1] != STDERR_FD)
{
dup2(fd[1], STDERR_FD);
shouldCloseFD1 = true;
}
if(shouldCloseFD1) close(fd[1]);
exit(processStage(cmd->left));
}
else
{
// parent
processTable[i].pid = pid;
// close the read end of the last pipe if it's not the orig stdin
if(i > 0)
{
close(fdIn);
}
fdIn = fd[0]; // remember the read end of the new pipe
close(fd[1]);
}
}
// cmd is now the right child of last PIPE or PIPE_ERR, the last stage of
// the pipeline
// if the last stage is a built-in command, it should affect the parent
// shell, so execute it here instead of forking off a process
if(cmd->type == SIMPLE && IS_BUILTIN(cmd->argv[0]))
{
processTable[numStages - 1].pid = -1; // unused pid
processTable[numStages - 1].status = processSimple(cmd, false);
close(fdIn);
}
else if((pid = fork()) < 0)
{
perror(EXEC_NAME);
return errno;
}
else if(pid == 0)
{
// child
if(fdIn != STDIN_FD)
{
dup2(fdIn, STDIN_FD);
close(fdIn);
}
exit(processStage(cmd));
}
else
{
// parent
processTable[numStages - 1].pid = pid;
close(fdIn);
}
// wait for children to die
signal(SIGINT, SIG_IGN);
for(int i = 0; i < numStages; )
{
pid = wait(&status);
int j;
for(j = 0; j < numStages && processTable[j].pid != pid; j++);
// only add to the processTable if the child's pid is in the table;
// that is, ignore zombies
if(j < numStages)
{
processTable[j].status = status;
i++;
}
}
signal(SIGINT, SIG_DFL);
for(int i = 0; i < numStages; i++)
{
if(GET_STATUS(processTable[i].status) != 0)
{
return GET_STATUS(processTable[i].status);
}
}
return 0;
}
/*
* Called by the CURRENT thread to inquire about the status of a transaction.
*/
int stm_aborted(TXPARAM)
{
TX_GET;
return (GET_STATUS(tx->status) == TX_ABORTED);
}
/**
* Function: module_imgbase_port_event_func
*
* Description: Event handler function for the imgbase port
*
* Arguments:
* @port: mct port pointer
* @event: mct event
*
* Return values:
* true/false
*
* Notes: none
**/
boolean module_imgbase_port_event_func(mct_port_t *port,
mct_event_t *event)
{
int rc = IMG_SUCCESS;
mct_module_t *p_mct_mod = NULL;
module_imgbase_t *p_mod = NULL;
imgbase_client_t *p_client;
boolean fwd_event = TRUE;
if (!port || !event) {
IDBG_ERROR("%s:%d invalid input", __func__, __LINE__);
return FALSE;
}
IDBG_LOW("%s:%d] port %p E", __func__, __LINE__, port);
p_mct_mod = MCT_MODULE_CAST((MCT_PORT_PARENT(port))->data);
if (!p_mct_mod) {
IDBG_ERROR("%s:%d invalid module", __func__, __LINE__);
return FALSE;
}
p_mod = (module_imgbase_t *)p_mct_mod->module_private;
if (NULL == p_mod) {
IDBG_ERROR("%s:%d] imgbase module NULL", __func__, __LINE__);
return FALSE;
}
p_client = (imgbase_client_t *)port->port_private;
if (NULL == p_client) {
IDBG_ERROR("%s:%d] imgbase client NULL", __func__, __LINE__);
return FALSE;
}
IDBG_LOW("%s:%d] type %d", __func__, __LINE__, event->type);
switch (event->type) {
case MCT_EVENT_CONTROL_CMD: {
mct_event_control_t *p_ctrl_event = &event->u.ctrl_event;
IDBG_MED("%s:%d] Ctrl type %d", __func__, __LINE__, p_ctrl_event->type);
switch (p_ctrl_event->type) {
case MCT_EVENT_CONTROL_STREAMON: {
IDBG_HIGH("%s:%d] IMGLIB_BASE STREAMON", __func__, __LINE__);
module_imgbase_client_start(p_client);
break;
}
case MCT_EVENT_CONTROL_STREAMOFF: {
module_imgbase_t *p_mod = (module_imgbase_t *)p_client->p_mod;
IDBG_MED("%s:%d] imgbase STREAMOFF", __func__, __LINE__);
module_imgbase_client_stop(p_client);
img_q_flush_and_destroy(&p_mod->msg_thread.msg_q);
img_q_flush_and_destroy(&p_client->stream_parm_q);
break;
}
case MCT_EVENT_CONTROL_PARM_STREAM_BUF: {
cam_stream_parm_buffer_t *parm_buf =
event->u.ctrl_event.control_event_data;
IDBG_HIGH("%s:%d] MCT_EVENT_CONTROL_PARM_STREAM_BUF %d",
__func__, __LINE__, parm_buf ? parm_buf->type : 0xffff);
if (parm_buf &&
(parm_buf->type == CAM_STREAM_PARAM_TYPE_GET_IMG_PROP)) {
cam_stream_parm_buffer_t *out_buf;
out_buf = img_q_dequeue(&p_client->stream_parm_q);
if (out_buf) {
*parm_buf = *out_buf;
free(out_buf);
}
}
break;
}
default:
break;
}
break;
}
case MCT_EVENT_MODULE_EVENT: {
mct_event_module_t *p_mod_event = &event->u.module_event;
img_component_ops_t *p_comp = &p_client->comp;
IDBG_MED("%s:%d] Mod type %d", __func__, __LINE__, p_mod_event->type);
switch (p_mod_event->type) {
case MCT_EVENT_MODULE_BUF_DIVERT: {
mod_img_msg_t msg;
isp_buf_divert_t *p_buf_divert =
(isp_buf_divert_t *)p_mod_event->module_event_data;
IDBG_ERROR("%s:%d] identity %x", __func__, __LINE__,
event->identity);
module_imgbase_client_handle_buffer(p_client, p_buf_divert);
/* indicate that the buffer is consumed */
p_buf_divert->is_locked = FALSE;
p_buf_divert->ack_flag = FALSE;
fwd_event = FALSE;
break;
}
case MCT_EVENT_MODULE_STATS_AWB_UPDATE: {
stats_update_t *stats_update = (stats_update_t *)
p_mod_event->module_event_data;
break;
}
case MCT_EVENT_MODULE_QUERY_DIVERT_TYPE: {
uint32_t *divert_mask = (uint32_t *)p_mod_event->module_event_data;
*divert_mask |= PPROC_DIVERT_PROCESSED;
break;
}
case MCT_EVENT_MODULE_SET_CHROMATIX_PTR:
break;
default:
break;
}
break;
}
default:
break;
}
if (fwd_event) {
boolean brc = module_imgbase_forward_port_event(p_client, port, event);
rc = (brc) ? IMG_SUCCESS : IMG_ERR_GENERAL;
}
return GET_STATUS(rc);
}
static int receive_pcb(elp_device * adapter, pcb_struct * pcb)
{
int i;
int total_length;
int stat;
int timeout;
CHECK_NULL(pcb);
CHECK_NULL(adapter);
/* get the command code */
timeout = jiffies + TIMEOUT;
while (((stat = GET_STATUS())&STATUS_ACRF) == 0 && jiffies < timeout)
;
if (jiffies >= timeout)
TIMEOUT_MSG();
SET_HSF(0);
pcb->command = INB(adapter->io_addr+PORT_COMMAND);
if ((stat & ASF_PCB_MASK) != ASF_PCB_END) {
/* read the data length */
timeout = jiffies + TIMEOUT;
while (((stat = GET_STATUS())&STATUS_ACRF) == 0 && jiffies < timeout)
;
if (jiffies >= timeout)
TIMEOUT_MSG();
pcb->length = INB(adapter->io_addr+PORT_COMMAND);
if (pcb->length > MAX_PCB_DATA)
printk(invalid_pcb_msg, pcb->length, filename,__LINE__);
if ((stat & ASF_PCB_MASK) != ASF_PCB_END) {
/* read the data */
i = 0;
timeout = jiffies + TIMEOUT;
do {
while (((stat = GET_STATUS())&STATUS_ACRF) == 0 && jiffies < timeout)
;
pcb->data.raw[i++] = INB(adapter->io_addr+PORT_COMMAND);
if (i > MAX_PCB_DATA)
printk(invalid_pcb_msg, i, filename, __LINE__);
} while ((stat & ASF_PCB_MASK) != ASF_PCB_END && jiffies < timeout);
if (jiffies >= timeout)
TIMEOUT_MSG();
/* woops, the last "data" byte was really the length! */
total_length = pcb->data.raw[--i];
/* safety check total length vs data length */
if (total_length != (pcb->length + 2)) {
if (elp_debug >= 2)
printk("%s: mangled PCB received\n", adapter->name);
SET_HSF(HSF_PCB_NAK);
return FALSE;
}
SET_HSF(HSF_PCB_ACK);
return TRUE;
}
}
SET_HSF(HSF_PCB_NAK);
return FALSE;
}
/**
* Function: module_imgbase_port_set_caps
*
* Description: This method is used to set the capabilities
*
* Arguments:
* @port: mct port pointer
* @caps: mct port capabilities
*
* Return values:
* error/success
*
* Notes: none
**/
boolean module_imgbase_port_set_caps(mct_port_t *port,
mct_port_caps_t *caps)
{
int rc = IMG_SUCCESS;
return GET_STATUS(rc);
}
/*
* Set the CURRENT transaction as irrevocable.
*/
static INLINE int
int_stm_set_irrevocable(stm_tx_t *tx, int serial)
{
#ifdef IRREVOCABLE_ENABLED
# if CM == CM_MODULAR
stm_word_t t;
# endif /* CM == CM_MODULAR */
if (!IS_ACTIVE(tx->status) && serial != -1) {
/* Request irrevocability outside of a transaction or in abort handler (for next execution) */
tx->irrevocable = 1 + (serial ? 0x08 : 0);
return 0;
}
/* Are we already in irrevocable mode? */
if ((tx->irrevocable & 0x07) == 3) {
return 1;
}
if (tx->irrevocable == 0) {
/* Acquire irrevocability for the first time */
tx->irrevocable = 1 + (serial ? 0x08 : 0);
#ifdef HYBRID_ASF
/* TODO: we shouldn't use pthread_mutex/cond since it could use syscall. */
if (tx->software == 0) {
asf_abort(ASF_RETRY_IRREVOCABLE);
return 0;
}
#endif /* HYBRID_ASF */
/* Try acquiring global lock */
if (_tinystm.irrevocable == 1 || ATOMIC_CAS_FULL(&_tinystm.irrevocable, 0, 1) == 0) {
/* Transaction will acquire irrevocability after rollback */
stm_rollback(tx, STM_ABORT_IRREVOCABLE);
return 0;
}
/* Success: remember we have the lock */
tx->irrevocable++;
/* Try validating transaction */
#if DESIGN == WRITE_BACK_ETL
if (!stm_wbetl_validate(tx)) {
stm_rollback(tx, STM_ABORT_VALIDATE);
return 0;
}
#elif DESIGN == WRITE_BACK_CTL
if (!stm_wbctl_validate(tx)) {
stm_rollback(tx, STM_ABORT_VALIDATE);
return 0;
}
#elif DESIGN == WRITE_THROUGH
if (!stm_wt_validate(tx)) {
stm_rollback(tx, STM_ABORT_VALIDATE);
return 0;
}
#elif DESIGN == MODULAR
if ((tx->attr.id == WRITE_BACK_CTL && stm_wbctl_validate(tx))
|| (tx->attr.id == WRITE_THROUGH && stm_wt_validate(tx))
|| (tx->attr.id != WRITE_BACK_CTL && tx->attr.id != WRITE_THROUGH && stm_wbetl_validate(tx))) {
stm_rollback(tx, STM_ABORT_VALIDATE);
return 0;
}
#endif /* DESIGN == MODULAR */
# if CM == CM_MODULAR
/* We might still abort if we cannot set status (e.g., we are being killed) */
t = tx->status;
if (GET_STATUS(t) != TX_ACTIVE || ATOMIC_CAS_FULL(&tx->status, t, t + (TX_IRREVOCABLE - TX_ACTIVE)) == 0) {
stm_rollback(tx, STM_ABORT_KILLED);
return 0;
}
# endif /* CM == CM_MODULAR */
if (serial && tx->w_set.nb_entries != 0) {
/* TODO: or commit the transaction when we have the irrevocability. */
/* Don't mix transactional and direct accesses => restart with direct accesses */
stm_rollback(tx, STM_ABORT_IRREVOCABLE);
return 0;
}
} else if ((tx->irrevocable & 0x07) == 1) {
/* Acquire irrevocability after restart (no need to validate) */
while (_tinystm.irrevocable == 1 || ATOMIC_CAS_FULL(&_tinystm.irrevocable, 0, 1) == 0)
;
/* Success: remember we have the lock */
tx->irrevocable++;
}
assert((tx->irrevocable & 0x07) == 2);
/* Are we in serial irrevocable mode? */
if ((tx->irrevocable & 0x08) != 0) {
/* Stop all other threads */
if (stm_quiesce(tx, 1) != 0) {
/* Another thread is quiescing and we are active (trying to acquire irrevocability) */
assert(serial != -1);
stm_rollback(tx, STM_ABORT_IRREVOCABLE);
return 0;
}
}
/* We are in irrevocable mode */
tx->irrevocable++;
#else /* ! IRREVOCABLE_ENABLED */
fprintf(stderr, "Irrevocability is not supported in this configuration\n");
exit(-1);
#endif /* ! IRREVOCABLE_ENABLED */
return 1;
}
