bool_t
receive_pridata(PDQCB *p_pdqcb, intptr_t *p_data,
PRI *p_datapri, bool_t *p_reqdsp)
{
TCB *p_tcb;
intptr_t data;
PRI datapri;
if (p_pdqcb->count > 0U) {
dequeue_pridata(p_pdqcb, p_data, p_datapri);
if (!queue_empty(&(p_pdqcb->swait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_pdqcb->swait_queue));
data = ((WINFO_PDQ *)(p_tcb->p_winfo))->data;
datapri = ((WINFO_PDQ *)(p_tcb->p_winfo))->datapri;
enqueue_pridata(p_pdqcb, data, datapri);
*p_reqdsp = wait_complete(p_tcb);
}
else {
*p_reqdsp = false;
}
return(true);
}
else if (!queue_empty(&(p_pdqcb->swait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_pdqcb->swait_queue));
*p_data = ((WINFO_PDQ *)(p_tcb->p_winfo))->data;
*p_datapri = ((WINFO_PDQ *)(p_tcb->p_winfo))->datapri;
*p_reqdsp = wait_complete(p_tcb);
return(true);
}
else {
return(false);
}
}
bool_t
receive_data(DTQCB *p_dtqcb, intptr_t *p_data, bool_t *p_reqdsp)
{
TCB *p_tcb;
intptr_t data;
if (p_dtqcb->count > 0U) {
dequeue_data(p_dtqcb, p_data);
if (!queue_empty(&(p_dtqcb->swait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_dtqcb->swait_queue));
data = ((WINFO_DTQ *)(p_tcb->p_winfo))->data;
enqueue_data(p_dtqcb, data);
*p_reqdsp = wait_complete(p_tcb);
}
else {
*p_reqdsp = false;
}
return(true);
}
else if (!queue_empty(&(p_dtqcb->swait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_dtqcb->swait_queue));
*p_data = ((WINFO_DTQ *)(p_tcb->p_winfo))->data;
*p_reqdsp = wait_complete(p_tcb);
return(true);
}
else {
return(false);
}
}
int i2c_write(uchar chip, uint addr, int alen, uchar *buf, int len)
{
int timeout = I2C_MAX_TIMEOUT;
char i = 0;
//printf("%s chip: 0x%02x addr: 0x%04x alen: %d len: %d, data: %d\n", __func__, chip, addr, alen, len, *buf);
__REG16(i2c_port_addr[i2c_port_num] + I2SR) = 0;
__REG16(i2c_port_addr[i2c_port_num] + I2CR) = I2CR_IEN;
/* Wait controller to be stable */
udelay(50);
__REG16(i2c_port_addr[i2c_port_num] + I2CR) |= I2CR_MSTA;
/* Start I2C transaction */
wait_busy();
__REG16(i2c_port_addr[i2c_port_num] + I2CR) |= I2CR_IIEN | I2CR_MTX | I2CR_TX_NO_AK;
__REG16(i2c_port_addr[i2c_port_num] + I2DR) = chip << 1;
wait_complete();
for(i = 0; i < len; i++){
__REG16(i2c_port_addr[i2c_port_num] + I2DR) = *(buf+i);
wait_complete();
}
__REG16(i2c_port_addr[i2c_port_num] + I2CR) &= ~(I2CR_MSTA | I2CR_MTX);
wait_idle();
__REG16(i2c_port_addr[i2c_port_num] + I2CR) = 0;
return 0;
}
ER
wup_tsk(ID tskid)
{
TCB *p_tcb;
ER ercd;
LOG_WUP_TSK_ENTER(tskid);
CHECK_TSKCTX_UNL();
CHECK_TSKID_SELF(tskid);
p_tcb = get_tcb_self(tskid);
t_lock_cpu();
if (TSTAT_DORMANT(p_tcb->tstat)) {
ercd = E_OBJ;
}
else if (TSTAT_WAIT_SLP(p_tcb->tstat)) {
if (wait_complete(p_tcb)) {
dispatch();
}
ercd = E_OK;
}
else if (!(p_tcb->wupque)) {
p_tcb->wupque = true;
ercd = E_OK;
}
else {
ercd = E_QOVR;
}
t_unlock_cpu();
error_exit:
LOG_WUP_TSK_LEAVE(ercd);
return(ercd);
}
static void write_atapi_register(void __iomem *base,
unsigned long ata_reg, unsigned short value)
{
/* Program the ATA_DEV_TXBUF register with write data (to be
* written into the device).
*/
ATAPI_SET_DEV_TXBUF(base, value);
/* Program the ATA_DEV_ADDR register with address of the
* device register (0x01 to 0x0F).
*/
ATAPI_SET_DEV_ADDR(base, ata_reg);
/* Program the ATA_CTRL register with dir set to write (1)
*/
ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | XFER_DIR));
/* ensure PIO DMA is not set */
ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~PIO_USE_DMA));
/* and start the transfer */
ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | PIO_START));
/* Wait for the interrupt to indicate the end of the transfer.
* (We need to wait on and clear rhe ATA_DEV_INT interrupt status)
*/
wait_complete(base, PIO_DONE_INT);
}
SYSCALL ER
iset_flg(ID flgid, FLGPTN setptn)
{
FLGCB *flgcb;
TCB *tcb;
WINFO_FLG *winfo;
ER ercd;
LOG_ISET_FLG_ENTER(flgid, setptn);
CHECK_INTCTX_UNL();
CHECK_FLGID(flgid);
flgcb = get_flgcb(flgid);
i_lock_cpu();
flgcb->flgptn |= setptn;
if (!(queue_empty(&(flgcb->wait_queue)))) {
tcb = (TCB *)(flgcb->wait_queue.next);
winfo = (WINFO_FLG *)(tcb->winfo);
if (eventflag_cond(flgcb, winfo->waiptn,
winfo->wfmode, &(winfo->flgptn))) {
queue_delete(&(tcb->task_queue));
if (wait_complete(tcb)) {
reqflg = TRUE;
}
}
}
ercd = E_OK;
i_unlock_cpu();
exit:
LOG_ISET_FLG_LEAVE(ercd);
return(ercd);
}
ER
iwup_tsk(ID tskid)
{
TCB *p_tcb;
ER ercd;
LOG_IWUP_TSK_ENTER(tskid);
CHECK_INTCTX_UNL();
CHECK_TSKID(tskid);
p_tcb = get_tcb(tskid);
i_lock_cpu();
if (TSTAT_DORMANT(p_tcb->tstat)) {
ercd = E_OBJ;
}
else if (TSTAT_WAIT_SLP(p_tcb->tstat)) {
if (wait_complete(p_tcb)) {
reqflg = true;
}
ercd = E_OK;
}
else if (!(p_tcb->wupque)) {
p_tcb->wupque = true;
ercd = E_OK;
}
else {
ercd = E_QOVR;
}
i_unlock_cpu();
error_exit:
LOG_IWUP_TSK_LEAVE(ercd);
return(ercd);
}
SYSCALL ER
sig_sem(ID semid)
{
SEMCB *semcb;
TCB *tcb;
ER ercd;
LOG_SIG_SEM_ENTER(semid);
CHECK_TSKCTX_UNL();
CHECK_SEMID(semid);
semcb = get_semcb(semid);
t_lock_cpu();
if (!(queue_empty(&(semcb->wait_queue)))) {
tcb = (TCB *) queue_delete_next(&(semcb->wait_queue));
if (wait_complete(tcb)) {
dispatch();
}
ercd = E_OK;
}
else if (semcb->semcnt < semcb->seminib->maxsem) {
semcb->semcnt += 1;
ercd = E_OK;
}
else {
ercd = E_QOVR;
}
t_unlock_cpu();
exit:
LOG_SIG_SEM_LEAVE(ercd);
return(ercd);
}
SYSCALL ER
iwup_tsk(ID tskid)
{
TCB *tcb;
UINT tstat;
ER ercd;
LOG_IWUP_TSK_ENTER(tskid);
CHECK_INTCTX_UNL();
CHECK_TSKID(tskid);
tcb = get_tcb(tskid);
i_lock_cpu();
if (TSTAT_DORMANT(tstat = tcb->tstat)) {
ercd = E_OBJ;
}
else if ((tstat & TS_WAIT_SLEEP) != 0) {
if (wait_complete(tcb)) {
reqflg = TRUE;
}
ercd = E_OK;
}
else if (!(tcb->wupcnt)) {
tcb->wupcnt = TRUE;
ercd = E_OK;
}
else {
ercd = E_QOVR;
}
i_unlock_cpu();
exit:
LOG_IWUP_TSK_LEAVE(ercd);
return(ercd);
}
SYSCALL ER
wup_tsk(ID tskid)
{
TCB *tcb;
UINT tstat;
ER ercd;
LOG_WUP_TSK_ENTER(tskid);
CHECK_TSKCTX_UNL();
CHECK_TSKID_SELF(tskid);
tcb = get_tcb_self(tskid);
t_lock_cpu();
if (TSTAT_DORMANT(tstat = tcb->tstat)) {
ercd = E_OBJ;
}
else if ((tstat & TS_WAIT_SLEEP) != 0) {
if (wait_complete(tcb)) {
dispatch();
}
ercd = E_OK;
}
else if (!(tcb->wupcnt)) {
tcb->wupcnt = TRUE;
ercd = E_OK;
}
else {
ercd = E_QOVR;
}
t_unlock_cpu();
exit:
LOG_WUP_TSK_LEAVE(ercd);
return(ercd);
}
static unsigned short read_atapi_register(void __iomem *base,
unsigned long ata_reg)
{
/* Program the ATA_DEV_ADDR register with address of the
* device register (0x01 to 0x0F).
*/
ATAPI_SET_DEV_ADDR(base, ata_reg);
/* Program the ATA_CTRL register with dir set to read (0) and
*/
ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~XFER_DIR));
/* ensure PIO DMA is not set */
ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~PIO_USE_DMA));
/* and start the transfer */
ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | PIO_START));
/* Wait for the interrupt to indicate the end of the transfer.
* (PIO_DONE interrupt is set and it doesn't seem to matter
* that we don't clear it)
*/
wait_complete(base, PIO_DONE_INT);
/* Read the ATA_DEV_RXBUF register with write data (to be
* written into the device).
*/
return ATAPI_GET_DEV_RXBUF(base);
}
JSP_L1_CODE
SYSCALL ER
isig_sem(ID semid)
{
SEMCB *semcb;
TCB *tcb;
ER ercd;
LOG_ISIG_SEM_ENTER(semid);
CHECK_INTCTX_UNL();
CHECK_SEMID(semid);
semcb = get_semcb(semid);
i_lock_cpu();
if (!queue_empty(&(semcb->wait_queue))) {
tcb = (TCB *) queue_delete_next(&(semcb->wait_queue));
if (wait_complete(tcb)) {
reqflg = TRUE;
}
ercd = E_OK;
}
else if (semcb->semcnt < semcb->seminib->maxsem) {
semcb->semcnt += 1;
ercd = E_OK;
}
else {
ercd = E_QOVR;
}
i_unlock_cpu();
exit:
LOG_ISIG_SEM_LEAVE(ercd);
return(ercd);
}
int i2c_probe(uchar chip)
{
int ret = 0;
__REG16(i2c_port_addr[i2c_port_num] + I2CR) = 0; /* Reset module */
__REG16(i2c_port_addr[i2c_port_num] + I2CR) = I2CR_IEN;
udelay(1000);
__REG16(i2c_port_addr[i2c_port_num] + I2CR) = I2CR_IEN | I2CR_MSTA | I2CR_MTX;
__REG16(i2c_port_addr[i2c_port_num] + I2DR) = (chip << 1);
wait_complete();
__REG16(i2c_port_addr[i2c_port_num] + I2CR) = I2CR_IEN;
return ret;
}
int i2c_read(uchar chip, uint addr, int alen, uchar *buf, int len)
{
int timeout = I2C_MAX_TIMEOUT;
char i = 0;
uchar temp = 0;
uchar temp2 = 0;
DPRINTF("%s chip: 0x%02x addr: 0x%04x alen: %d len: %d\n", __func__, chip, addr, alen, len);
__REG16(i2c_port_addr[i2c_port_num] + I2SR) = 0;
__REG16(i2c_port_addr[i2c_port_num] + I2CR) = I2CR_IEN;
/* Wait controller to be stable */
udelay(50);
__REG16(i2c_port_addr[i2c_port_num] + I2CR) |= I2CR_MSTA;
/* Start I2C transaction */
wait_busy();
__REG16(i2c_port_addr[i2c_port_num] + I2CR) |= I2CR_IIEN | I2CR_MTX | I2CR_TX_NO_AK;
__REG16(i2c_port_addr[i2c_port_num] + I2DR) = chip << 1;
wait_complete();
__REG16(i2c_port_addr[i2c_port_num] + I2DR) = addr; // address 0 -> version
wait_complete(); // write finish: address and addr
//DPRINTF("i2c_read: write addr done\n");
udelay(500);
__REG16(i2c_port_addr[i2c_port_num] + I2CR) = I2CR_IEN | I2CR_MSTA | I2CR_MTX | I2CR_RSTA;
/* Restart I2C transaction */
wait_busy();
__REG16(i2c_port_addr[i2c_port_num] + I2DR) = (chip << 1) | 0x01;
wait_complete();
//DPRINTF("i2c_read: read action send\n");
udelay(500);
__REG16(i2c_port_addr[i2c_port_num] + I2CR) = I2CR_IEN | I2CR_MSTA | I2CR_TX_NO_AK;
temp = __REG16(i2c_port_addr[i2c_port_num] + I2DR);
wait_complete();
__REG16(i2c_port_addr[i2c_port_num] + I2CR) &= ~(I2CR_MSTA | I2CR_MTX);
wait_idle();
*buf = __REG16(i2c_port_addr[i2c_port_num] + I2DR);
DPRINTF("i2c_read temp: 0x%x, buf: 0x%x\n", temp, *buf);
__REG16(i2c_port_addr[i2c_port_num] + I2CR) = 0;
return 0;
}
ER
set_flg(ID flgid, FLGPTN setptn)
{
FLGCB *p_flgcb;
QUEUE *p_queue;
TCB *p_tcb;
WINFO_FLG *p_winfo_flg;
ER ercd;
bool_t dspreq = false;
PCB *p_pcb;
LOG_SET_FLG_ENTER(flgid, setptn);
CHECK_TSKCTX_UNL();
CHECK_FLGID(flgid);
p_flgcb = get_flgcb(flgid);
t_lock_cpu();
t_acquire_obj_lock(&GET_OBJLOCK(p_flgcb));
p_flgcb->flgptn |= setptn;
p_queue = p_flgcb->wait_queue.p_next;
while (p_queue != &(p_flgcb->wait_queue)) {
p_tcb = (TCB *) p_queue;
p_queue = p_queue->p_next;
/* フラグのセットを非破壊コードにできないため，リトライしない */
p_pcb = acquire_nested_tsk_lock_without_preemption(p_tcb);
p_winfo_flg = (WINFO_FLG *)(&(p_tcb->winfo_obj));
if (check_flg_cond(p_flgcb, p_winfo_flg->waiptn,
p_winfo_flg->wfmode, &(p_winfo_flg->flgptn))) {
queue_delete(&(p_tcb->task_queue));
if (wait_complete(p_tcb)) {
if (dispatch_request(p_pcb)) {
dspreq = true;
}
}
if ((p_flgcb->p_flginib->flgatr & TA_CLR) != 0U) {
release_nested_tsk_lock(p_pcb);
break;
}
}
release_nested_tsk_lock(p_pcb);
}
ercd = E_OK;
release_obj_lock(&GET_OBJLOCK(p_flgcb));
if (dspreq) {
dispatch();
}
t_unlock_cpu();
error_exit:
LOG_SET_FLG_LEAVE(ercd);
return(ercd);
}
ER
set_flg(ID flgid, FLGPTN setptn)
{
FLGCB *p_flgcb;
QUEUE *p_queue;
TCB *p_tcb;
WINFO_FLG *p_winfo_flg;
bool_t dspreq = false;
ER ercd;
LOG_SET_FLG_ENTER(flgid, setptn);
CHECK_TSKCTX_UNL();
CHECK_FLGID(flgid);
p_flgcb = get_flgcb(flgid);
t_lock_cpu();
if (p_flgcb->p_flginib->flgatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (VIOLATE_ACPTN(p_flgcb->p_flginib->acvct.acptn1)) {
ercd = E_OACV;
}
else {
p_flgcb->flgptn |= setptn;
p_queue = p_flgcb->wait_queue.p_next;
while (p_queue != &(p_flgcb->wait_queue)) {
p_tcb = (TCB *) p_queue;
p_queue = p_queue->p_next;
p_winfo_flg = (WINFO_FLG *)(p_tcb->p_winfo);
if (check_flg_cond(p_flgcb, p_winfo_flg->waiptn,
p_winfo_flg->wfmode, &(p_winfo_flg->flgptn))) {
queue_delete(&(p_tcb->task_queue));
if (wait_complete(p_tcb)) {
dspreq = true;
}
if ((p_flgcb->p_flginib->flgatr & TA_CLR) != 0U) {
break;
}
}
}
if (dspreq) {
dispatch();
}
ercd = E_OK;
}
t_unlock_cpu();
error_exit:
LOG_SET_FLG_LEAVE(ercd);
return(ercd);
}
ER
rel_mpf(ID mpfid, void *blk)
{
MPFCB *p_mpfcb;
size_t blkoffset;
uint_t blkidx;
TCB *p_tcb;
ER ercd;
LOG_REL_MPF_ENTER(mpfid, blk);
CHECK_TSKCTX_UNL();
CHECK_ID(VALID_MPFID(mpfid));
p_mpfcb = get_mpfcb(mpfid);
lock_cpu();
if (p_mpfcb->p_mpfinib->mpfatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else {
blkoffset = ((char *) blk) - (char *)(p_mpfcb->p_mpfinib->mpf);
blkidx = (uint_t)(blkoffset / p_mpfcb->p_mpfinib->blksz);
if (!(p_mpfcb->p_mpfinib->mpf <= blk)
|| !(blkoffset % p_mpfcb->p_mpfinib->blksz == 0U)
|| !(blkoffset / p_mpfcb->p_mpfinib->blksz < p_mpfcb->unused)
|| !((p_mpfcb->p_mpfinib->p_mpfmb + blkidx)->next
== INDEX_ALLOC)) {
ercd = E_PAR;
}
else if (!queue_empty(&(p_mpfcb->wait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_mpfcb->wait_queue));
((WINFO_MPF *)(p_tcb->p_winfo))->blk = blk;
wait_complete(p_tcb);
if (p_runtsk != p_schedtsk) {
dispatch();
}
ercd = E_OK;
}
else {
p_mpfcb->fblkcnt++;
(p_mpfcb->p_mpfinib->p_mpfmb + blkidx)->next = p_mpfcb->freelist;
p_mpfcb->freelist = blkidx;
ercd = E_OK;
}
}
unlock_cpu();
error_exit:
LOG_REL_MPF_LEAVE(ercd);
return(ercd);
}
bool_t
force_send_data(DTQCB *p_dtqcb, intptr_t data)
{
TCB *p_tcb;
if (!queue_empty(&(p_dtqcb->rwait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_dtqcb->rwait_queue));
((WINFO_DTQ *)(p_tcb->p_winfo))->data = data;
return(wait_complete(p_tcb));
}
else {
force_enqueue_data(p_dtqcb, data);
return(false);
}
}
ER
wup_tsk(ID tskid)
{
TCB *p_tcb;
ER ercd;
LOG_WUP_TSK_ENTER(tskid);
CHECK_UNL();
if (tskid == TSK_SELF && !sense_context()) {
p_tcb = p_runtsk;
}
else {
CHECK_ID(VALID_TSKID(tskid));
p_tcb = get_tcb(tskid);
}
lock_cpu();
if (p_tcb->p_tinib->tskatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (TSTAT_DORMANT(p_tcb->tstat)) {
ercd = E_OBJ;
}
else if (TSTAT_WAIT_SLP(p_tcb->tstat)) {
wait_complete(p_tcb);
if (p_runtsk != p_schedtsk) {
if (!sense_context()) {
dispatch();
}
else {
request_dispatch();
}
}
ercd = E_OK;
}
else if (!(p_tcb->wupque)) {
p_tcb->wupque = true;
ercd = E_OK;
}
else {
ercd = E_QOVR;
}
unlock_cpu();
error_exit:
LOG_WUP_TSK_LEAVE(ercd);
return(ercd);
}
void
messagebuf_signal(MBFCB *p_mbfcb)
{
TCB *p_tcb;
while (!queue_empty(&(p_mbfcb->swait_queue))) {
p_tcb = (TCB *)(p_mbfcb->swait_queue.p_next);
if (enqueue_message(p_mbfcb, ((WINFO_SMBF *)(p_tcb->p_winfo))->msg,
((WINFO_SMBF *)(p_tcb->p_winfo))->msgsz)) {
queue_delete(&(p_tcb->task_queue));
wait_complete(p_tcb);
}
else {
break;
}
}
}
ER
sig_sem(ID semid)
{
SEMCB *p_semcb;
TCB *p_tcb;
ER ercd;
LOG_SIG_SEM_ENTER(semid);
CHECK_UNL();
CHECK_ID(VALID_SEMID(semid));
p_semcb = get_semcb(semid);
lock_cpu();
if (p_semcb->p_seminib->sematr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (VIOLATE_ACPTN(p_semcb->p_seminib->acvct.acptn1)) {
ercd = E_OACV;
}
else if (!queue_empty(&(p_semcb->wait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_semcb->wait_queue));
wait_complete(p_tcb);
if (p_runtsk != p_schedtsk) {
if (!sense_context()) {
dispatch();
}
else {
request_dispatch_retint();
}
}
ercd = E_OK;
}
else if (p_semcb->semcnt < p_semcb->p_seminib->maxsem) {
p_semcb->semcnt += 1;
ercd = E_OK;
}
else {
ercd = E_QOVR;
}
unlock_cpu();
error_exit:
LOG_SIG_SEM_LEAVE(ercd);
return(ercd);
}
ER
snd_mbx(ID mbxid, T_MSG *pk_msg)
{
MBXCB *p_mbxcb;
TCB *p_tcb;
ER ercd;
LOG_SND_MBX_ENTER(mbxid, pk_msg);
CHECK_TSKCTX_UNL();
CHECK_MBXID(mbxid);
p_mbxcb = get_mbxcb(mbxid);
CHECK_PAR((p_mbxcb->p_mbxinib->mbxatr & TA_MPRI) == 0U
|| (TMIN_MPRI <= MSGPRI(pk_msg)
&& MSGPRI(pk_msg) <= p_mbxcb->p_mbxinib->maxmpri));
t_lock_cpu();
if (!queue_empty(&(p_mbxcb->wait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_mbxcb->wait_queue));
((WINFO_MBX *)(p_tcb->p_winfo))->pk_msg = pk_msg;
if (wait_complete(p_tcb)) {
dispatch();
}
ercd = E_OK;
}
else if ((p_mbxcb->p_mbxinib->mbxatr & TA_MPRI) != 0U) {
enqueue_msg_pri(&(p_mbxcb->pk_head), pk_msg);
ercd = E_OK;
}
else {
pk_msg->pk_next = NULL;
if (p_mbxcb->pk_head != NULL) {
p_mbxcb->pk_last->pk_next = pk_msg;
}
else {
p_mbxcb->pk_head = pk_msg;
}
p_mbxcb->pk_last = pk_msg;
ercd = E_OK;
}
t_unlock_cpu();
error_exit:
LOG_SND_MBX_LEAVE(ercd);
return(ercd);
}
ER
iset_flg(ID flgid, FLGPTN setptn)
{
FLGCB *p_flgcb;
QUEUE *p_queue;
TCB *p_tcb;
WINFO_FLG *p_winfo_flg;
ER ercd;
LOG_ISET_FLG_ENTER(flgid, setptn);
CHECK_INTCTX_UNL();
CHECK_FLGID(flgid);
p_flgcb = get_flgcb(flgid);
i_lock_cpu();
if (p_flgcb->p_flginib->flgatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else {
p_flgcb->flgptn |= setptn;
p_queue = p_flgcb->wait_queue.p_next;
while (p_queue != &(p_flgcb->wait_queue)) {
p_tcb = (TCB *) p_queue;
p_queue = p_queue->p_next;
p_winfo_flg = (WINFO_FLG *)(p_tcb->p_winfo);
if (check_flg_cond(p_flgcb, p_winfo_flg->waiptn,
p_winfo_flg->wfmode, &(p_winfo_flg->flgptn))) {
queue_delete(&(p_tcb->task_queue));
if (wait_complete(p_tcb)) {
reqflg = true;
}
if ((p_flgcb->p_flginib->flgatr & TA_CLR) != 0U) {
break;
}
}
}
ercd = E_OK;
}
i_unlock_cpu();
error_exit:
LOG_ISET_FLG_LEAVE(ercd);
return(ercd);
}
bool_t
send_pridata(PDQCB *p_pdqcb, intptr_t data, PRI datapri)
{
TCB *p_tcb;
if (!queue_empty(&(p_pdqcb->rwait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_pdqcb->rwait_queue));
((WINFO_RPDQ *)(p_tcb->p_winfo))->data = data;
((WINFO_RPDQ *)(p_tcb->p_winfo))->datapri = datapri;
wait_complete(p_tcb);
return(true);
}
else if (p_pdqcb->count < p_pdqcb->p_pdqinib->pdqcnt) {
enqueue_pridata(p_pdqcb, data, datapri);
return(true);
}
else {
return(false);
}
}
bool_t
send_data(DTQCB *p_dtqcb, intptr_t data, bool_t *p_reqdsp)
{
TCB *p_tcb;
if (!queue_empty(&(p_dtqcb->rwait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_dtqcb->rwait_queue));
((WINFO_DTQ *)(p_tcb->p_winfo))->data = data;
*p_reqdsp = wait_complete(p_tcb);
return(true);
}
else if (p_dtqcb->count < p_dtqcb->p_dtqinib->dtqcnt) {
enqueue_data(p_dtqcb, data);
*p_reqdsp = false;
return(true);
}
else {
return(false);
}
}
bool_t
send_message(MBFCB *p_mbfcb, const void *msg, uint_t msgsz)
{
TCB *p_tcb;
if (!queue_empty(&(p_mbfcb->rwait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_mbfcb->rwait_queue));
memcpy(((WINFO_RMBF *)(p_tcb->p_winfo))->msg, msg, msgsz);
wait_complete(p_tcb);
p_tcb->p_winfo->wercd = (ER_UINT)(msgsz);
return(true);
}
else if (queue_empty(&(p_mbfcb->swait_queue))
&& enqueue_message(p_mbfcb, msg, msgsz)) {
return(true);
}
else {
return(false);
}
}
ER
rel_mpf(ID mpfid, void *blk)
{
MPFCB *p_mpfcb;
SIZE blkoffset;
uint_t blkidx;
TCB *p_tcb;
ER ercd;
LOG_REL_MPF_ENTER(mpfid, blk);
CHECK_TSKCTX_UNL();
CHECK_MPFID(mpfid);
p_mpfcb = get_mpfcb(mpfid);
CHECK_PAR(p_mpfcb->p_mpfinib->mpf <= blk);
blkoffset = ((char *) blk) - (char *)(p_mpfcb->p_mpfinib->mpf);
CHECK_PAR(blkoffset % p_mpfcb->p_mpfinib->blksz == 0U);
CHECK_PAR(blkoffset / p_mpfcb->p_mpfinib->blksz < p_mpfcb->unused);
blkidx = (uint_t)(blkoffset / p_mpfcb->p_mpfinib->blksz);
CHECK_PAR((p_mpfcb->p_mpfinib->p_mpfmb + blkidx)->next == INDEX_ALLOC);
t_lock_cpu();
if (!queue_empty(&(p_mpfcb->wait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_mpfcb->wait_queue));
((WINFO_MPF *)(p_tcb->p_winfo))->blk = blk;
if (wait_complete(p_tcb)) {
dispatch();
}
ercd = E_OK;
}
else {
p_mpfcb->fblkcnt++;
(p_mpfcb->p_mpfinib->p_mpfmb + blkidx)->next = p_mpfcb->freelist;
p_mpfcb->freelist = blkidx;
ercd = E_OK;
}
t_unlock_cpu();
error_exit:
LOG_REL_MPF_LEAVE(ercd);
return(ercd);
}
bool_t
messagebuf_signal(MBFCB *p_mbfcb)
{
TCB *p_tcb;
bool_t dspreq = false;
while (!queue_empty(&(p_mbfcb->swait_queue))) {
p_tcb = (TCB *)(p_mbfcb->swait_queue.p_next);
if (enqueue_message(p_mbfcb, ((WINFO_MBF *)(p_tcb->p_winfo))->msg,
((WINFO_MBF *)(p_tcb->p_winfo))->msgsz)) {
queue_delete(&(p_tcb->task_queue));
if (wait_complete(p_tcb)) {
dspreq = true;
}
}
else {
break;
}
}
return(dspreq);
}
bool_t
send_message(MBFCB *p_mbfcb, const void *msg, uint_t msgsz, bool_t *p_dspreq)
{
TCB *p_tcb;
if (!queue_empty(&(p_mbfcb->rwait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_mbfcb->rwait_queue));
memcpy(((WINFO_MBF *)(p_tcb->p_winfo))->msg, msg, msgsz);
((WINFO_MBF *)(p_tcb->p_winfo))->msgsz = msgsz;
*p_dspreq = wait_complete(p_tcb);
return(true);
}
else if (have_precedence(p_mbfcb)
&& enqueue_message(p_mbfcb, msg, msgsz)) {
*p_dspreq = false;
return(true);
}
else {
return(false);
}
}
uint_t
receive_message(MBFCB *p_mbfcb, void *msg, bool_t *p_dspreq)
{
TCB *p_tcb;
uint_t msgsz;
if (p_mbfcb->smbfcnt > 0) {
msgsz = dequeue_message(p_mbfcb, msg);
*p_dspreq = messagebuf_signal(p_mbfcb);
return(msgsz);
}
else if (!queue_empty(&(p_mbfcb->swait_queue))) {
p_tcb = (TCB *) queue_delete_next(&(p_mbfcb->swait_queue));
msgsz = ((WINFO_MBF *)(p_tcb->p_winfo))->msgsz;
memcpy(msg, ((WINFO_MBF *)(p_tcb->p_winfo))->msg, msgsz);
*p_dspreq = wait_complete(p_tcb);
return(msgsz);
}
else {
return(0U);
}
}