/*! Sends BYTE to the serial port. */
void serial_putc(uint8_t byte) {
enum intr_level old_level = intr_disable();
if (mode != QUEUE) {
/* If we're not set up for interrupt-driven I/O yet,
use dumb polling to transmit a byte. */
if (mode == UNINIT)
init_poll();
putc_poll(byte);
}
else {
/* Otherwise, queue a byte and update the interrupt enable register. */
if (old_level == INTR_OFF && intq_full(&txq)) {
/* Interrupts are off and the transmit queue is full.
If we wanted to wait for the queue to empty,
we'd have to reenable interrupts.
That's impolite, so we'll send a character via
polling instead. */
putc_poll(intq_getc (&txq));
}
intq_putc(&txq, byte);
write_ier();
}
intr_set_level(old_level);
}
int btsock_thread_create(btsock_signaled_cb callback, btsock_cmd_cb cmd_callback)
{
int ret = FALSE;
asrt(callback || cmd_callback);
lock_slot(&thread_slot_lock);
int h = alloc_thread_slot();
unlock_slot(&thread_slot_lock);
APPL_TRACE_DEBUG1("alloc_thread_slot ret:%d", h);
if(h >= 0)
{
init_poll(h);
if((ts[h].thread_id = create_thread(sock_poll_thread, (void*)h)) != -1)
{
APPL_TRACE_DEBUG2("h:%d, thread id:%d", h, ts[h].thread_id);
ts[h].callback = callback;
ts[h].cmd_callback = cmd_callback;
}
else
{
free_thread_slot(h);
h = -1;
}
}
return h;
}
int init(int argc, char *argv[])
{
mtn = mtn_init(MODULE_NAME);
ctx = calloc(1,sizeof(CTX));
if(!mtn){
return(-1);
}
if(!ctx){
mtnlogger(NULL, 0, "[error] %s: %s\n", __func__, strerror(errno));
return(-1);
}
mtn->mps_max = 512;
mtn->logtype = 0;
mtn->logmode = MTNLOG_STDERR;
ctx->afd = -1;
ctx->nobuf = 1;
ctx->text = 1;
ctx->delim = newstr(" ");
ctx->targets = newarg(0);
ctx->arg_max = sysconf(_SC_ARG_MAX);
ctx->cpu_num = sysconf(_SC_NPROCESSORS_ONLN);
ctx->job_max = sysconf(_SC_NPROCESSORS_ONLN);
ctx->cmdargs = parse(argc, argv);
gettimeofday(&(ctx->polltv), NULL);
if(init_pipe() == -1){
return(-1);
}
if(init_poll() == -1){
return(-1);
}
ctx->job = calloc(ctx->job_max, sizeof(MTNJOB));
set_signal_handler();
mtnlogger(mtn, 1, "LogLevel: %d\n", mtn->loglevel);
return(0);
}
int init_agent(agent_t *agent)
{
init_poll(agent);
create_listen_sockets(agent);
init_controller_listener(&agent->controller);
/* add controller socket to POLL set */
agent->listen_fds.event_controller.events = POLLIN;
agent->listen_fds.event_controller.data.ptr = &agent->listen_fds.controller_message_event;
agent->listen_fds.controller_message_event.type = CONTROLLER_MESSAGE;
agent->listen_fds.controller_message_event.fd = agent->controller.port;
if( epoll_ctl(agent->event_pool, EPOLL_CTL_ADD,
agent->controller.sock, &agent->listen_fds.event_controller))
{
perror("");
printf("%s %d\n", __FILE__, __LINE__);
exit(1);
}
init_discovery(&agent->discovery);
return EXIT_SUCCESS;
}
/*! Initializes the serial port device for queued interrupt-driven
I/O. With interrupt-driven I/O we don't waste CPU time
waiting for the serial device to become ready. */
void serial_init_queue(void) {
enum intr_level old_level;
if (mode == UNINIT)
init_poll();
ASSERT(mode == POLL);
intr_register_ext(0x20 + 4, serial_interrupt, "serial");
mode = QUEUE;
old_level = intr_disable();
write_ier();
intr_set_level(old_level);
}
/* Initializes the serial port device for queued interrupt-driven
I/O. With interrupt-driven I/O we don't waste CPU time
waiting for the serial device to become ready. */
void
serial_init_queue(void)
{
unsigned old_level;
if (mode == UNINIT)
init_poll();
int_register(0x20 + 4, serial_interrupt, 0, 0);
mode = QUEUE;
old_level = int_intr_disable();
write_ier();
int_intr_setlevel(old_level);
}
/* Sends BYTE to the serial port. */
void
serial_putc(unsigned char byte)
{
unsigned old_level = int_intr_disable();
if (mode != QUEUE)
{
/* If we're not set up for interrupt-driven I/O yet,
use dumb polling to transmit a byte. */
if (mode == UNINIT)
init_poll();
putc_poll(byte);
}
else
{
/* Otherwise, queue a byte and update the interrupt enable
register. */
if (old_level == 0 && cyb_isfull(txq))
{
/* Interrupts are off and the transmit queue is full.
If we wanted to wait for the queue to empty,
we'd have to reenable interrupts.
That's impolite, so we'll send a character via
polling instead. */
putc_poll(cyb_getc(txq));
}
if (byte == '\n')
{
cyb_putc(txq, '\r');
}
cyb_putc(txq, byte);
write_ier();
}
int_intr_setlevel(old_level);
}
void InitROM(void)
{
w32 saved_regs[16];
char qvers[6];
char *initstr="UQLX v%s, release\012 %s\012QDOS Version %s\012";
long sysvars,sxvars;
if((long)((Ptr)gPC-(Ptr)theROM)-2 != ROMINIT_CMD_ADDR)
{ exception=4;
extraFlag=true;
return;
}
#if 0
printf("a6=%x, basic at %x\n",aReg[6],ReadLong(0x28010));
#endif
save_regs(saved_regs);
do_update=1; /* flip in screen RAM */
#ifdef OLD_PATCH
/* lea $0C000,a3 */
aReg[3]=0x0c000;
gPC+=2;
#else
#warning UNUSED OLD_PATCH
WW((Ptr)gPC-2,0x0c93); /* restore original instruction */
#endif
#if 0
KillSound();
CloseSerial();
InitSerial();
ZeroKeyboardBuffer();
#endif
/* delete old MDV drivers (for optical reasons) */
WriteLong(0x28048,0);
InitFileDrivers();
InitDrivers();
#ifdef XSCREEN
/*printf("call init_xscreen\n");*/
init_xscreen();
#else
#warning UNUSED XSCREEN
#endif
SchedInit();
init_bas_exts();
QLtrap(1,0,20000l);
#if 0
printf("QDOS vars at %x, trap res=%d, RTOP=%d\n",aReg[0],reg[0],RTOP);
#endif
sysvars=aReg[0];
sxvars=RL((Ptr)theROM+sysvars+0x7c);
#if 0
if (isMinerva)
printf("Minerva extended vars at %x\n",sxvars);
#endif
if (V3)
printf("sysvars at %x, ux RAMTOP %d, sys.ramt %d, qlscreen at %d\n",
sysvars,RTOP,sysvar_l(20),qlscreen.qm_lo);
// QDOS version
WL((Ptr)qvers,reg[2]);qvers[4]=0;
#if 0
p=(Ptr)theROM+RTOP-0x07FFEl;
sprintf(p,initstr,uqlx_version,release,qvers);
WriteWord(aReg[1]=RTOP-0x08000l,strlen(p));
#if 1
QLvector(0xd0,200000);
#else
WriteLong((*sp)-=4,(w32)gPC-(w32)theROM);
gPC=(uw16*)((Ptr)theROM+RW((uw16*)((Ptr)theROM+0xd0))); /* write string */
#endif
#endif
/*HACK: allow breakpoints in ROM*/
#if DEBUG_ROM
RamMap[0]=RamMap[1]=RamMap[2]=3;
uqlx_protect(0,3*32768,QX_RAM);
#endif
/* now install TKII defaults */
reg[1]=0x6c;
reg[2]=0;
QLtrap(1,0x18,200000);
if(reg[0]==0){
if (V3)printf("Initialising TK2 device defaults\n");
WriteLong(0x28070+0x3c,aReg[0]);
WriteLong(0x28070+0x40,32+aReg[0]);
WriteLong(0x28070+0x44,64+aReg[0]);
WriteWord(aReg[0],strlen(DATAD));strcpy((char*)((Ptr)theROM+aReg[0]+2),DATAD);
WriteWord(aReg[0]+32,strlen(PROGD));strcpy((char*)((Ptr)theROM+aReg[0]+34),PROGD);
WriteWord(aReg[0]+64,strlen(SPOOLD));strcpy((char*)((Ptr)theROM+aReg[0]+66),SPOOLD);
}
/* link in Minerva keyboard handling */
#if 1
if (isMinerva)
{
reg[1]=8;
reg[2]=0;
QLtrap(1,0x18,200000);
if(reg[0]==0)
{
WW((Ptr)theROM+MIPC_CMD_ADDR,MIPC_CMD_CODE);
WL((Ptr)theROM+aReg[0],RL((Ptr)theROM+sxvars+0x14));
WL((Ptr)theROM+aReg[0]+4,MIPC_CMD_ADDR);
WL((Ptr)theROM+sxvars+0x14,aReg[0]);
}
WW((Ptr)theROM+KBENC_CMD_ADDR,KBENC_CMD_CODE);
orig_kbenc=RL((Ptr)theROM+sxvars+0x10);
WL((Ptr)theROM+sxvars+0x10,KBENC_CMD_ADDR);
#if 0
printf("orig_kbenc=%x\nreplacement kbenc=%x\n",orig_kbenc,KBENC_CMD_ADDR);
printf("sx_kbenc addr=%x\n",sxvars+0x10);
#endif
}
#endif
init_poll();
/* make sure it wasn't changed somewhere */
restore_regs(saved_regs);
#ifdef OLD_PATCH
aReg[3]=0x0c000;
#endif
#ifndef OLD_PATCH
table[code=0x0c93](); /* run the original routine */
#endif
}
int iface_ghp_main(void)
/****************************************************************/
{
//int i = 0;
//unsigned char tempVal = 0;
// int j = 0;
int st = 0;
int result = 0;
//DEL point_info point;
//int pollingCount = 0;
IfaceGhpSelectSleep(3, 0);
/* initialize ghp interface */
init_data();
clear_tx_buf(); // clear tx buffer.
clear_rx_buf(); // clear rx buffer.
set_pcm_number(); // set pcm nummber.
init_uart(); // init uart2 channel.
init_poll();
get_sddc(); // get sddc number.
get_unit_cnt(); // get indoor unit count.
get_ghp_data(); // get ghp-point data.
init_queue();
g_CntHaksaInit = 0;
/*
Test Code.
반드시 현장에서 지워야 한다.
*/
while( 1 ) {
IfaceGhpSelectSleep(3, 0);
}
/*
uart2 통신에 의한 Delay가 발생하는 상황을 재현하고자 한다.
Test가 끝나면 반드시 주석으로 막아 실행되지 않도록 한다.
*/
#if 0
printf("Test Code\n");
memset(txbuf, 0, sizeof(txbuf));
for (i = 0; i < 256; i++) {
txbuf[i] = tempVal++;
}
printf("init poll\n");
init_poll();
while(1)
{
result = OnReadIn();
if ( 0 < result ) {
printf("Rx (%d)\n", result);
/*
for (i = 0; i < result; i++) {
printf("%x ", rxbuf[i]);
}
printf("\n\n");
*/
printf("Write\n");
OnWriteOut(rxbuf, result);
printf("scehdule\n");
Check_Schedule(g_unitCnt);
}
}
#endif
#if 0
while( 1 ) {
IfaceGhpSelectSleep(1, 0);
Chk_Group_Control();
// 전체 정지 모드
Set_AllStopMode(g_unitCnt);
// 실내기 온도 제한
Set_Temperature(g_unitCnt);
}
#endif
//super loop
st = ST_GET_POLLING;
do{
// 전체 정지 모드
Set_AllStopMode(g_unitCnt);
// 실내기 온도 제한
Set_Temperature(g_unitCnt);
Get_RunUnit(g_unitCnt);
// 각 동의 층별제어 및 실내기 타입별 온도제어를 한다.
Chk_Group_Control();
// jong2ry test.
// It is scheduler function.
Check_Schedule(g_unitCnt);
//sleep(1);
//continue;
Set_AllHaksaMode(g_unitCnt);
switch(st)
{
case ST_GET_POLLING:
//if(g_dbgShow) printf("ST_GET_POLLING\n");
result = Send_Polling();
//printf("result = %d\n", result);
switch(result)
{
case POLL_REQUIRE_STARTUP:
st = ST_STARTUP;
break;
case POLL_EMPTY_DATA:
case POLL_OK:
if (Send_Polling() == POLL_REQUIRE_STARTUP) {
st = ST_STARTUP;
break;
}
else {
st = ST_CHK_USER_CONTROL;
break;
}
default:
//if(g_dbgShow) printf(">>> POLLING ERROR\n");
st = ST_CHK_USER_CONTROL;
break;
}
break;
case ST_CHK_USER_CONTROL:
CheckUserControl();
st = ST_GET_USER_CONTROL;
break;
case ST_GET_USER_CONTROL:
//if(g_dbgShow) printf("ST_GET_USER_CONTROL\n");
while(Do_User_Control()) {
if (Send_Polling() == POLL_REQUIRE_STARTUP) {
st = ST_STARTUP;
break;
}
// 전체 정지 모드
Set_AllStopMode(g_unitCnt);
// 실내기 온도 제한
Set_Temperature(g_unitCnt);
Get_RunUnit(g_unitCnt);
// 각 동의 층별제어 및 실내기 타입별 온도제어를 한다.
Chk_Group_Control();
}
st = ST_GET_GHP_UNIT;
break;
case ST_GET_GHP_UNIT:
//if(g_dbgShow) printf("ST_GET_GHP_UNIT\n");
Get_Ghp_Unit();
if (Send_Polling() == POLL_REQUIRE_STARTUP) {
st = ST_STARTUP;
break;
}
//if(g_dbgShow) printf("\n\n");
st = ST_GET_POLLING;
break;
case ST_STARTUP:
//if(g_dbgShow) printf("ST_STARTUP\n");
Startup_SDDC();
st = ST_GET_POLLING;
break;
default:
//if(g_dbgShow) printf("default\n");
st = ST_GET_POLLING;
break;
}
}while(1);
//exit(1);
system("killall duksan");
}
