/*
* Get memory
*/
LOCAL void* imalloc( size_t size, IMACB *imacb )
{
QUEUE *q;
VP mem;
UW imask;
/* If it is smaller than the minimum fragment size,
allocate the minimum size to it. */
if ( size < MIN_FRAGMENT ) {
size = MIN_FRAGMENT;
}
size = ROUND(size);
DI(imask); /* Exclusive control by interrupt disable */
SpinLock(&MemLockObj);
/* Search FreeQue */
q = searchFreeArea(size, imacb);
if ( q != &imacb->freeque ) {
/* There is free area: Split from FreeQue once */
removeFreeQue(q);
q = q - 1;
} else {
/* Reserve new pages because there is no free space */
QUEUE *e;
size_t n;
/* Reserve pages */
SpinUnlock(&MemLockObj);
EI(imask);
n = PageCount(size + sizeof(QUEUE) * 2);
q = GetSysMemBlk(n, imacb->mematr);
if ( q == NULL ) {
goto err_ret; /* Insufficient memory */
}
DI(imask);
SpinLock(&MemLockObj);
/* Register on AreaQue */
e = (QUEUE*)((VB*)q + n * pagesz) - 1;
insertAreaQue(&imacb->areaque, e);
insertAreaQue(&imacb->areaque, q);
setAreaFlag(q, AREA_TOP);
setAreaFlag(e, AREA_END);
}
/* Allocate memory */
mem = mem_alloc(q, size, imacb);
SpinUnlock(&MemLockObj);
EI(imask);
return mem;
err_ret:
BMS_DEBUG_PRINT(("imalloc error\n"));
return NULL;
}
int uart_putchar(unsigned char c)
{
int buffer_loc;
if(c == '\n') {
while(uart_putchar('\r')) {
;
}
}
if(trans_buffer_size < BUFFER_SIZE) {
DI();
buffer_loc = (trans_buffer_current + trans_buffer_size) % BUFFER_SIZE;
trans_buffer[buffer_loc] = c;
trans_buffer_size++;
//trigger the interrupt if already ready to transmit
if((U0STAT0 & UART_TRAN_RDY) &&
((IRQ0SET & UART_IRQ_TRAN) == 0)) {
IRQ0SET |= UART_IRQ_TRAN;
}
EI();
}
else {
return 1;
}
return 0;
}
void led_display_text(const unsigned char *msg)
{
char *new_msg;
msg_size = strlen(msg);
new_msg = malloc(sizeof(*new_msg) * (msg_size + 2)); //+2 for space pad and null terminator
if(!new_msg) {
msg_size = 0;
}
else {
memcpy(new_msg, msg, msg_size);
//space pads the wrap-around
if(msg_size > 4) {
new_msg[msg_size] = ' ';
++msg_size;
}
new_msg[msg_size] = '\0';
DI();
if(led_msg != NULL) {
free(led_msg);
}
led_msg = new_msg;
msg_pos = 0;
row_pos = 0;
led_set_draw_chars();
EI();
}
}
/**
* @param timer The timer to stop
*/
void hal_timer_stop(char timer)
{
DI();
switch (timer) {
case HAL_TIMER_0:
T0CTL &= ~0x80; //Disable timer
break;
case HAL_TIMER_1:
T1CTL &= ~0x80;
break;
case HAL_TIMER_2:
T2CTL &= ~0x80;
break;
case HAL_TIMER_3:
T3CTL &= ~0x80;
break;
default:
break;
}
EI();
}
SifRpcDataQueue_t *
SifSetRpcQueue(SifRpcDataQueue_t *qd, int thread_id)
{
SifRpcDataQueue_t *queue = NULL;
DI();
qd->thread_id = thread_id;
qd->active = 0;
qd->link = NULL;
qd->start = NULL;
qd->end = NULL;
qd->next = NULL;
if (!_sif_rpc_data.active_queue) {
_sif_rpc_data.active_queue = qd;
} else {
queue = _sif_rpc_data.active_queue;
while ((queue = queue->next))
;
queue->next = qd;
}
EI();
return queue;
}
SifRpcServerData_t *
SifRegisterRpc(SifRpcServerData_t *sd,
int sid, SifRpcFunc_t func, void *buff, SifRpcFunc_t cfunc,
void *cbuff, SifRpcDataQueue_t *qd)
{
SifRpcServerData_t *server;
DI();
sd->link = NULL;
sd->next = NULL;
sd->sid = sid;
sd->func = func;
sd->buff = buff;
sd->cfunc = cfunc;
sd->cbuff = cbuff;
sd->base = qd;
if (!(server = qd->link)) {
qd->link = sd;
} else {
while ((server = server->next))
;
server->next = sd;
}
EI();
return server;
}
int buscarIzquierdaAVL( AVL *a, int dato, int *band )
{
int retAux;
retAux = eliminaAVL( &(*a)->izq, dato, band );
if( *band )
{
if( (*a) -> fe == 0 )
{
(*a) -> fe = 1;
*band = 0;
}else
if( (*a) -> fe == -1 )
(*a) -> fe = 0;
else
{
if( (*a) -> der -> fe >= 0 )
{
if( (*a) -> der -> fe == 0 )
*band = 0;
DD( a );
}else
DI( a );
}
}
return( retAux );
}
int eliminaAVL( AVL *a, int dato, int *band )
{
int ret;
AVL aux;
if( !*a )
*band = ret = 0;
else
{
if( dato == (*a) -> info )
{
ret = *band = 1;
aux = *a;
if( !(*a) -> izq )
*a = (*a)-> der;
else
if( !(*a) -> der )
*a = (*a) -> izq;
else
{
recorreIzqDerAVL( &(*a) -> izq, &aux, band );
(*a) -> info = aux -> info;
if( *band )
{
if( (*a) -> fe == 0 )
{
(*a) -> fe = 1;
*band = 0;
}else
if( (*a) -> fe == -1 )
(*a) -> fe = 0;
else
{
if( (*a) -> der -> fe >= 0 )
{
if( (*a) -> der -> fe == 0 )
*band = 0;
DD( a );
}else
DI( a );
}
}
}
free( aux );
}else
if( dato < (*a) -> info )
ret = buscarIzquierdaAVL( a, dato, band );
else
if( dato > (*a) -> info )
ret= buscarDerechaAVL( a, dato, band );
}
return( ret );
}
/***********************************************************************************************************************
* Function Name: R_Systeminit
* Description : This function initializes every macro.
* Arguments : None
* Return Value : None
***********************************************************************************************************************/
void R_Systeminit(void)
{
DI();
/* Enable writing to registers related to operating modes, LPC, CGC and ATCM */
SYSTEM.PRCR.LONG = 0x0000A50BU;
/* Enable writing to MPC pin function control registers */
MPC.PWPR.BIT.B0WI = 0U;
MPC.PWPR.BIT.PFSWE = 1U;
r_set_exception_handler();
/* Set peripheral settings */
R_CGC_Create();
R_ICU_Create();
R_PORT_Create();
R_TPU_Create();
R_RSPI1_Create();
R_MPC_Create();
R_SCIFA2_Create();
/* Disable writing to MPC pin function control registers */
MPC.PWPR.BIT.PFSWE = 0U;
MPC.PWPR.BIT.B0WI = 1U;
/* Enable protection */
SYSTEM.PRCR.LONG = 0x0000A500U;
EI();
}
int io_init()
{
int i;
int res;
it_g = comedi_open("/dev/comedi0");
if (it_g == NULL) return -1;
// init 3 inputs and 3 outputs
for(i=1; i<4; i++)
{
res = comedi_dio_config(it_g, IO_DEV, DI(i), COMEDI_INPUT);
if (res<0) return res;
res = comedi_dio_config(it_g, IO_DEV, DO(i), COMEDI_OUTPUT);
if (res<0) return res;
res = comedi_dio_write(it_g, IO_DEV, DO(i), 0);
if (res<0) return res;
}
// set outputs to high
for(i=1; i<4; i++)
{
comedi_dio_write(it_g, IO_DEV, DO(i), 1);
}
return 1;
}
int main(){
DI();//disable interrupts or hell breaks loose during hardware config
construct_system();//bind device addresses
init_system();//init devices
//clear all interrupts
clearall_interrupts();
EI();//enable interrupts: we have UART_recieve
//set the lcd contrast
//lcd_contrast(0x42);
lcd_contrast(0x32);
//clear the lcd
clearram();
//show boot up message
show_bootup();
//clear boot message
clearram();
//screen layout
screen_layout();
send(1, 225);
send(1, 255);
send(1, 2);
while(1)
{
get_temperature1();
get_temperature2();
get_light();
get_pressure();
get_humidity();
get_soilwetness();
display();
delay_ms(800);
}
return 0;
}
int
ki_wait (struct k_t *sem, int timeout)
{
// used by msg system
DI ();
if (0 < sem->cnt1) {
// lucky that we do not need to wait ?
sem->cnt1--; // Salute to Dijkstra
return (0);
}
if (timeout == -1) {
// no luck, dont want to wait so bye bye
return (-2);
}
// from here we want to wait
pRun->cnt2 = timeout; // if 0 then wait forever
if (timeout)
pRun->cnt3 = (int) sem; // nasty keep ref to semaphor
// so we can be removed if timeout occurs
sem->cnt1--; // Salute to Dijkstra
enQ (sem, deQ (pRun));
ki_task_shift (); // call enables NOT interrupt on return
return ((char) (pRun->cnt2)); // 0: ok, -1: timeout
}
int PS2CamReadPacket(int handle)
{
int *ret;
int *iop_addr;
WaitSema(sem);
ret = (int *)&data[0];
ret[0] = handle;
SifCallRpc(&cdata, PS2CAM_RPC_READPACKET, 0, (void*)(&data[0]),4,(void*)(&data[0]),4*2,0,0);
if(ret[0] < 0) return ret[0];
DI();
ee_kmode_enter();
iop_addr = (int *)(0xbc000000+ret[1]);
memcpy(&campacket[0],iop_addr, ret[0]);
ee_kmode_exit();
EI();
//if i add a printf here, the ps2 will exit to sony's explorer
SignalSema(sem);
return ret[0];
}
char
ki_receive (struct k_msg_t *pB, void *el, int *lost_msg)
{
int i;
char r, *pSrc, *pDst;
// can be called from ISR bq no blocking
DI (); // just to be sure
if (0 <= (r = ki_wait (pB->sem, -1))) {
pDst = (char *) el;
pB->r++;
pB->cnt--; // got one
if (pB->nr_el <= pB->r) {
pB->r = 0;
}
pSrc = pB->pBuf + pB->r * pB->el_size;
for (i = 0; i < pB->el_size; i++) {
*(pDst++) = *(pSrc++);
}
if (lost_msg) {
*lost_msg = pB->lost_msg;
pB->lost_msg = 0;
}
return (r); // yes
}
return (-1); // nothing for you my friend
}
int
k_mut_ceil_enter (struct k_t *sem, int timeout)
{
int retval;
DI ();
// if ceiling_prio < 0 then its a normal wait call
if (sem->ceiling_prio < 0) {
retval = ki_wait (sem, timeout); // could call k_wait but just extra fct call
EI ();
return retval;
}
if (pRun->prio < sem->ceiling_prio) { // I have higher priority than ceiling :-(
EI ();
return CEILINGFAIL;
}
// now we play imm ceiling protocol
sem->saved_prio = pRun->prio; // do im ceiling
pRun->prio = sem->ceiling_prio; // dont need to reinsert in AQ bq ceil prio is higher or equal to mine and Im already in front of AQ
prio_enQ (pAQ, deQ (pRun)); // resinsert me in AQ acc to nwe(old) priority
retval = ki_wait (sem, timeout);
// coming back interrupt is still disabled !
// chk if we did get semaphore
if (retval < 0) { // NOPE we did not
pRun->prio = sem->saved_prio; // reset to my old priority
prio_enQ (pAQ, deQ (pRun)); // reinsert me in AQ acc to nwe(old) priority
ki_task_shift (); // bq maybe started task has higher prio than me
}
EI ();
return retval; // 0(has waited),1(straight through) : ok, -1: timeout
}
int
ki_semval (struct k_t *sem)
{
DI ();
return (sem->cnt1);
}
int
ki_signal (struct k_t *sem)
{
DI (); // just in case
if (sem->cnt1 < sem->maxv) {
sem->cnt1++; // Salute to Dijkstra
if (sem->cnt1 <= 0) {
sem->next->cnt2 = 0; // return code == ok
prio_enQ (pAQ, deQ (sem->next));
return (0); // task was waiting
}
return (1); // just delivered a signal - no task was waiting
}
if (SEM_MAX_VALUE > sem->clip) {
sem->clip++;
}
// here we are on bad clip failure no signal takes place
// signal is lost !!!
#ifdef KRNLBUG
k_sem_clip (sem->nr, sem->clip);
#endif
return (-1);
}
int
ki_wait (struct k_t *sem, int timeout)
{
DI ();
if (0 < sem->cnt1) {
sem->cnt1--; // Salute to Dijkstra
k_sem_unclip (sem->nr);
return (1); // ok: 1 bq we are not suspended
}
if (timeout < 0) // no luck, dont want to wait so bye bye
{
return (-2);
}
// from here we want to wait
pRun->cnt2 = timeout; // 0 == wait forever
if (timeout) { // so we can be removed if timeout occurs
pRun->cnt3 = (int) sem; // nasty keep ref to semaphore in task stomach
}
sem->cnt1--; // Salute to Dijkstra
k_sem_unclip (sem->nr);
enQ (sem, deQ (pRun));
ki_task_shift ();
// back again - have semaphore received signal or timeout ?
pRun->cnt3 = 0; // reset ref to timer semaphore
return ((char) (pRun->cnt2)); // 0: ok , -1: timeout
}
int main(int argc, char**argv)
{
int err;
sqlite3 *conn;
char *errmsg;
err = sqlite3_open("test.sl3",&conn);
Table *t = table_new(TableCsv | TableColumns);
err = sqlite3_exec(conn,"select * from test",
table_add_row,t,&errmsg);
if (err) {
printf("err '%s'\n",errmsg);
return 1;
}
table_finish_rows(t);
DUMPA(float,(float*)t->cols[1],"%f");
sqlite3_close(conn);
unref(t);
DI(obj_kount());
return 0;
}
static void TxThread(void *arg)
{
int ThreadToWakeUp;
while(1)
{
SleepThread();
if(PacketReqs.count > 0)
{
while(PacketReqs.count > 0)
{
WaitSema(NetManIOSemaID);
while(SifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_SEND_PACKETS, 0, &PacketReqs, sizeof(PacketReqs), &ReceiveBuffer, sizeof(ReceiveBuffer.result), &TxEndCallback, NULL) < 0){};
SignalSema(NetManIOSemaID);
}
}
else
{
if(NetmanTxWaitingThread >= 0)
{
DI();
ThreadToWakeUp=NetmanTxWaitingThread;
NetmanTxWaitingThread=-1;
EI();
WakeupThread(ThreadToWakeUp);
}
}
}
}
/***********************************************************************************************************************
* Function Name: __low_level_init
* Description : This function initializes hardware setting.
* Arguments : None
* Return Value : None
***********************************************************************************************************************/
int __low_level_init(void)
{
DI();
R_Systeminit();
return (1U);
}
/***********************************************************************************************************************
* Function Name: HardwareSetup
* Description : This function initializes hardware setting.
* Arguments : None
* Return Value : None
***********************************************************************************************************************/
int HardwareSetup(void)
{
DI();
R_Systeminit();
return (1U);
}
char
k_receive (struct k_msg_t *pB, void *el, int timeout, int *lost_msg)
{
int i;
char *pSrc, *pDst;
DI ();
if (ki_wait (pB->sem, timeout) == 0) {
// ki_wait bq then intr is not enabled when coming back
pDst = (char *) el;
pB->r++;
pB->cnt--; // got one
if (pB->nr_el <= pB->r)
pB->r = 0;
pSrc = pB->pBuf + pB->r * pB->el_size;
for (i = 0; i < pB->el_size; i++) {
*(pDst++) = *(pSrc++);
}
if (lost_msg) {
*lost_msg = pB->lost_msg;
pB->lost_msg = 0;
}
EI ();
return (0); // yes
}
EI ();
return (-1); // nothing for you my friend
}
int
k_wait (struct k_t *sem, int timeout)
{
// copy of ki_wait just with EI()'s before leaving
DI ();
if (0 < sem->cnt1) { // lucky that we do not need to wait ?
sem->cnt1--; // Salute to Dijkstra
EI ();
return (0);
}
if (timeout == -1) { // no luck, dont want to wait so bye
EI ();
return (-2);
}
// from here we have to wait
pRun->cnt2 = timeout; // if 0 then wait forever
if (timeout)
pRun->cnt3 = (int) sem; // nasty keep ref to semaphore,
// so we can be removed if timeout occurs
sem->cnt1--; // Salute to Dijkstra
enQ (sem, deQ (pRun));
ki_task_shift (); // call enables interrupt on return
EI ();
return (char) (pRun->cnt2); // 0: ok, -1: timeout
}
void
k_reset ()
{
DI ();
wdt_enable (WDTO_15MS);
while (1);
}
/*
* Free memory
* It may be called during interrupt disable. In this case, need to wait
* until interrupt is enabled and until free.
*/
EXPORT void knl_Ifree( void *ptr )
{
QUEUE *aq;
UINT imask;
DI(imask); /* Exclusive control by interrupt disable */
aq = (QUEUE*)ptr - 1;
clrAreaFlag(aq, AREA_USE);
if ( !chkAreaFlag(aq->next, AREA_USE) ) {
/* Merge with free area in after location */
knl_removeFreeQue(aq->next + 1);
knl_removeAreaQue(aq->next);
}
if ( !chkAreaFlag(aq->prev, AREA_USE) ) {
/* Merge with free area in front location */
aq = aq->prev;
knl_removeFreeQue(aq + 1);
knl_removeAreaQue(aq->next);
}
knl_appendFreeArea(knl_imacb, aq);
EI(imask);
}
int
k_set_prio (char prio)
{
int i;
if (!k_running) {
return (-2);
}
DI ();
if ((prio <= 0) || (DMY_PRIO <= prio)) // not legal value my friend
{
EI ();
return (-1);
}
i = pRun->prio;
pRun->prio = prio;
prio_enQ (pAQ, deQ (pRun));
ki_task_shift ();
EI ();
return (i);
}
unsigned char midi_out_send_standard_msg(unsigned char status, unsigned char data1, unsigned char data2)
{
unsigned char buffer_loc;
if(msg_buffer_size < (MIDI_MSG_BUFFER_SIZE - 2)) {
DI();
buffer_loc = (msg_buffer_current + msg_buffer_size) % MIDI_MSG_BUFFER_SIZE;
midi_msg_buffer[buffer_loc] = status;
msg_buffer_size++;
buffer_loc = (msg_buffer_current + msg_buffer_size) % MIDI_MSG_BUFFER_SIZE;
midi_msg_buffer[buffer_loc] = data1;
msg_buffer_size++;
buffer_loc = (msg_buffer_current + msg_buffer_size) % MIDI_MSG_BUFFER_SIZE;
midi_msg_buffer[buffer_loc] = data2;
msg_buffer_size++;
//trigger the interrupt if already ready to transmit
if((U1STAT0 & UART1_TRAN_RDY) &&
((IRQ2SET & UART1_IRQ_EN) == 0)) {
IRQ2SET |= UART1_IRQ_EN;
}
EI();
}
else {
return 1;
}
return 0;
}
/** Initializes audsrv library
@returns error code
*/
int audsrv_init()
{
int ret;
if (initialized)
{
/* already done */
return 0;
}
memset(&cd0, '\0', sizeof(cd0));
while (1)
{
if (SifBindRpc(&cd0, AUDSRV_IRX, 0) < 0)
{
set_error(AUDSRV_ERR_RPC_FAILED);
return -1;
}
if (cd0.server != 0)
{
break;
}
nopdelay();
}
ee_sema_t compSema;
compSema.init_count = 1;
compSema.max_count = 1;
compSema.option = 0;
completion_sema = CreateSema(&compSema);
if (completion_sema < 0)
{
set_error(AUDSRV_ERR_FAILED_TO_CREATE_SEMA);
return -1;
}
SifCallRpc(&cd0, AUDSRV_INIT, 0, sbuff, 64, sbuff, 64, NULL, NULL);
ret = sbuff[0];
if (ret != 0)
{
set_error(ret);
return ret;
}
/* register a callback handler */
DI();
SifAddCmdHandler(AUDSRV_CDDA_CALLBACK, cdda_stopped, NULL);
SifAddCmdHandler(AUDSRV_FILLBUF_CALLBACK, fillbuf_requested, NULL);
EI();
/* initialize IOP heap (for adpcm samples) */
SifInitIopHeap();
set_error(AUDSRV_ERR_NOERROR);
return AUDSRV_ERR_NOERROR;
}
void DNF::setup_names()
{
if (pres_debug>=2)
fprintf(DebugFile,"Setting up names for DNF 0x%p\n", this);
for(DNF_Iterator DI(this); DI.live(); DI.next())
DI.curr()->setup_names();
}
