vm.c

/*
 * Fake joystick driver for Linux
 * by Alexandre Hardy
 */

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "program.h"
#include "mapper.h"
#include "clock.h"
#include "keys.h"

#define INTERVAL    50
#define STACK_SIZE    1024
#define MAX_THREADS    8

#define debug(...)
//#define debug printf

static int installed=0;

static int timestamp=0;
static int tick=0;
static __uint64_t started=0;
static int executing=0;

//controller variables
static __int16_t code_analog[64];
//controller variables
static __uint8_t code_bit[128];
//controller variables
static __int16_t js_analog[16][64];
//controller variables
static __uint8_t js_bit[16][128];
static __int16_t currentmode=0;
static __int16_t firstscan=1;
static __int16_t clocktick=1;
static __int16_t xrel=0;
static __int16_t yrel=0;
static __int16_t zrel=0;
static __uint8_t code[MAX_CODE_SIZE];
//registers inaccessible to user
//allocated by compiler
static int status=0;        //0 = no valid program 1=valid program
static struct code_context {
    unsigned int ip;
    int registers[256]; //general purpose registers
    int sp;
    int stack[STACK_SIZE];
    int active; //is this thread active
} code_threads[MAX_THREADS];

//for each instruction, does it have an operand
static char has_operand[]={
    0, /* HALT */
    1, /* JZ */
    1, /* JUMP */
    1, /* JUMPREL */
    0, /* ADD */
    0, /* SUB */
    0, /* MUL */
    0, /* DIV */
    0, /* LT */
    0, /* LE */
    0, /* GT */
    0, /* GE */
    0, /* EQ */
    0, /* NEQ */
    0, /* AND */
    0, /* OR */
    0, /* NOT */
    1, /* PUSH */
    1, /* POP */
    1, /* DEC */
    1, /* INC */
    0, /* KEY */
    0, /* SIGNAL */
    1, /* THREAD handles its own arguments */
    0, /* YIELD */
    0, /* NEG */
    1, /* JOIN */
    1, /* PUSHA */
    1, /* POPA */
    1, /* DECA */
    1, /* INCA */
};

struct code_context *code_thread;

void code_button(int code, int value);
void code_axis(int axis, int value);
void execute_script(void);

void code_notify_button(int js, int key, int value) {
    if ((js>=0)&&(js<16))
    if ((key-BTN_JOYSTICK>=0)&&(key-BTN_JOYSTICK<128)) {
        if (js_bit[js][key-BTN_JOYSTICK]!=value) {
            js_bit[js][key-BTN_JOYSTICK]=value;
            program_run();
        }
    }
}

void code_notify_axis(int js, int axis, int value) {
    if ((js>=0)&&(js<16))
    if ((axis>=0)&&(axis<64)) {
        if (js_analog[js][axis]!=value) {
            js_analog[js][axis]=value;
            program_run();
        }
    }
}

void code_set_program(struct program_code *program) {
    if (program==NULL) {
        status=0;
        return;
    }
    if (program->program!=PROGRAM_CODE) return;
    memcpy(code, program->code, MAX_CODE_SIZE);
    firstscan=1;
    currentmode=0;
    timestamp=0;
    status=1;
}

void code_reset(void) {
    int i, j;
    for (i=0; i<MAX_THREADS; i++) {
        for (j=0; j<256; j++) {
             code_threads[i].registers[j]=0;
        }
        code_threads[i].active=0;
    }
    code_threads[0].active=1;
    for (i=0; i<64; i++) {
        code_analog[i]=0;
    }
    for (i=0; i<128; i++) {
        code_bit[i]=0;
    }
    firstscan=1;
    currentmode=0;
    timestamp=0;
    started=0;
}

static void push(int x) {
    if (code_thread->sp<STACK_SIZE) code_thread->stack[code_thread->sp++]=x;
}

static int pop(void) {
    if (code_thread->sp<=0) return 0;
    else return code_thread->stack[--code_thread->sp];
}

static int get_value(int address, int type, int array) {
    int js;
    int ofs=0;
    if (array)
        ofs=code_thread->registers[OFSREG];
    switch (type) {
        case GP:
            if (address+ofs==FIRSTSCAN) return firstscan;
            if (address+ofs==CLOCKTICK) return clocktick;
            if (address+ofs==XREL) return xrel;
            if (address+ofs==YREL) return yrel;
            if (address+ofs==ZREL) return zrel;
            if (address+ofs==TIMESTAMP) return timestamp;
            if (address+ofs==CURRENTMODE) return currentmode;
            if ((address+ofs>=0)&&(address+ofs<256))
                return code_thread->registers[address+ofs];
            else
                return 0;
        case GLOBAL:
            if (address+ofs==FIRSTSCAN) return firstscan;
            if (address+ofs==CLOCKTICK) return clocktick;
            if (address+ofs==XREL) return xrel;
            if (address+ofs==YREL) return yrel;
            if (address+ofs==ZREL) return zrel;
            if (address+ofs==TIMESTAMP) return timestamp;
            if (address+ofs==CURRENTMODE) return currentmode;
            if ((address+ofs>=0)&&(address+ofs<256))
                return code_threads[0].registers[address+ofs];
            else
                return 0;
        case CODEA:
            if ((address+ofs>=0)&&(address+ofs<64))
                return code_analog[address+ofs];
            else
                return 0;
        case CODEB:
            if ((address+ofs>=0)&&(address+ofs<128))
                return code_bit[address+ofs];
            else
                return 0;
        case JS:
            js=(address&0x0F00)>>8;
            type=address&0xF000;
            address=address&0x00FF;
            if (type==0) {
                if ((address+ofs>=0)&&(address+ofs<128))
                    return js_bit[js][address+ofs];
                else
                    return 0;
            } else {
                if ((address+ofs>=0)&&(address+ofs<64))
                    return js_analog[js][address+ofs];
                else
                    return 0;
            }
        case CONST:
            return address;
        default:
            return 0;
    }
}

static void set_value(int address, int type, int value, int array) {
    int ofs=0;
    if (array)
        ofs=code_thread->registers[OFSREG];
    switch (type) {
        case GP:
            if (address==XREL) xrel=value;
            if (address==YREL) yrel=value;
            if (address==ZREL) zrel=value;
            if (address==CURRENTMODE) currentmode=value;
            if ((address+ofs>=0)&&(address+ofs<256))
                code_thread->registers[address+ofs]=value;
            break;
        case GLOBAL:
            if (address==XREL) xrel=value;
            if (address==YREL) yrel=value;
            if (address==ZREL) zrel=value;
            if (address==CURRENTMODE) currentmode=value;
            if ((address+ofs>=0)&&(address+ofs<256))
                code_threads[0].registers[address+ofs]=value;
            break;
        case CODEA:
            if ((address+ofs>=0)&&(address+ofs<64))
                code_axis(address+ofs, value);
            break;
        case CODEB:
            if ((address+ofs>=0)&&(address+ofs<128))
                code_button(address+ofs, value);
            break;
        case JS:
        case CONST:
            break;
        default:
            break;
    }
}

static int instr_exec=0;

static void execute_script_thread(struct code_context *new_thread, unsigned int new_ip, unsigned int retip);
void execute_script(void) {
    if (executing) return;
    executing=1;
    code_thread=&code_threads[0];
    code_thread->ip=0;
    code_thread->sp=0;
    code_thread->active=1;
    instr_exec=0;
    debug("\n\nstart thread\n");
    debug("timestamp %d\n", timestamp);
    execute_script_thread(code_thread,0,MAX_CODE_SIZE);
    firstscan=0;
    clocktick=0;
    executing=0;
}

static void execute_script_thread(struct code_context *new_thread, unsigned int new_ip, unsigned int retip) {
    int address=0, array=0;
    int type;
    int task;
    int st;
    int p1, p2;
    int value=0;
    unsigned int thread_start;
    unsigned int thread_exit;
    if (status!=1) return;
    if (!new_thread->active) {
        debug("Activating thread\n");
        *new_thread=*code_thread;
        new_thread->ip=new_ip;
        //code_thread->ip=retip;
        code_thread=new_thread;
        new_thread->active=1;
    } else {
        code_thread=new_thread;
    }
    while ((code_thread->ip<MAX_CODE_SIZE)&&(instr_exec<100000)) {
        task=code[code_thread->ip++];
        type=task >> 5;
        task=task&31;
        if (task>=PUSHA) array=1;
        else array=0;
        if ((task>=0)&&(task<=INCA))
        if (has_operand[task]) {
            address=*((unsigned short *)(code+code_thread->ip));
            value=get_value(address, type, array);
            code_thread->ip+=2;
            debug("Got operand %d address=%d type=%d\n",value, address, type);
        }
        instr_exec++;
        switch (task) {
            case HALT:
                debug("HALT\n");
                code_thread->ip=MAX_CODE_SIZE+1;
                code_thread->active=0;
                break;
            case JZ:
                debug("JZ\n");
                st=pop();
                if (st==0) code_thread->ip=value;
                break;
            case JUMP:
                debug("JUMP\n");
                code_thread->ip=value;
                break;
            case JUMPREL:
                debug("JUMPREL\n");
                code_thread->ip+=value;
                break;
            case ADD:
                debug("ADD\n");
                p1=pop();
                p2=pop();
                push(p2+p1);
                break;
            case SUB:
                debug("SUB\n");
                p1=pop();
                p2=pop();
                push(p2-p1);
                break;
            case MUL:
                debug("MUL\n");
                p1=pop();
                p2=pop();
                push(p2*p1);
                break;
            case DIV:
                debug("DIV\n");
                p1=pop();
                p2=pop();
                push(p2/p1);
                break;
            case LT:
                debug("LT\n");
                p1=pop();
                p2=pop();
                push((p2<p1)?1:0);
                break;
            case LE:
                debug("LE\n");
                p1=pop();
                p2=pop();
                push((p2<=p1)?1:0);
                break;
            case GT:
                debug("GT\n");
                p1=pop();
                p2=pop();
                push((p2>p1)?1:0);
                break;
            case GE:
                debug("GE\n");
                p1=pop();
                p2=pop();
                push((p2>=p1)?1:0);
                break;
            case EQ:
                debug("EQ\n");
                p1=pop();
                p2=pop();
                push((p2==p1)?1:0);
                break;
            case NEQ:
                debug("NEQ\n");
                p1=pop();
                p2=pop();
                push((p2!=p1)?1:0);
                break;
            case AND:
                debug("AND\n");
                p1=pop();
                p2=pop();
                push((p2&&p1)?1:0);
                break;
            case OR:
                debug("OR\n");
                p1=pop();
                p2=pop();
                push((p2||p1)?1:0);
                break;
            case NOT:
                debug("NOT\n");
                p1=pop();
                push((!p1)?1:0);
                break;
            case NEG:
                debug("NEG\n");
                p1=pop();
                push(-p1);
                break;
            case PUSH:
                debug("PUSH %d\n", value);
                push(value);
                break;
            case POP:
                value=pop();
                debug("POP %d\n", value);
                set_value(address, type, value, 0);
                break;
            case DEC:
                debug("DEC\n");
                set_value(address, type, value-1, 0);
                break;
            case INC:
                debug("INC\n");
                set_value(address, type, value+1, 0);
                break;
            case PUSHA:
                debug("PUSHA %d\n", value);
                push(value);
                break;
            case POPA:
                value=pop();
                debug("POPA %d\n", value);
                set_value(address, type, value, 1);
                break;
            case DECA:
                debug("DECA\n");
                set_value(address, type, value-1, 1);
                break;
            case INCA:
                debug("INCA\n");
                set_value(address, type, value+1, 1);
                break;
            case KEY:
                p2=pop();
                p1=pop();
                debug("KEY %d %d\n", p1, p2);
                press_key(p1, p2);
                break;
            case SIGNAL:
                debug("SIGNAL\n");
                value=pop();
                push_signal(value);
                break;
            case THREAD: //context switch, value is new thread, two constant jump targets
                //thread_start=*((unsigned short *)(code+code_thread->ip));
                //code_thread->ip+=2;
                debug("THREAD %d\n", value);
                thread_exit=*((unsigned short *)(code+code_thread->ip));
                code_thread->ip+=2;
                thread_start=code_thread->ip;
                if ((value>0)&&(value<MAX_THREADS)) {
                    execute_script_thread(&code_threads[value], thread_start, thread_exit);
                    code_thread=new_thread;
                    code_thread->ip=thread_exit;
                } else {
                    debug("Not a valid thread\n");
                    code_thread=new_thread;
                    code_thread->ip=thread_exit;
                }
                break;
            case YIELD:
                debug("YIELD\n");
                return;
                break;
            case JOIN: //stop thread
                debug("JOIN %d\n", value);
                if ((value>0)&&(value<MAX_THREADS)) {
                    code_thread[value].active=0;
                }
                break;
        }
    }
}

int mapper_code_install(void) {
    int i, j;
    if (installed) return 0;

    for (j=0; j<16; j++) {
        for (i=0; i<64; i++) {
            js_analog[j][i]=0;
        }
        for (i=0; i<128; i++) {
            js_bit[j][i]=0;
        }
    }

    installed=1;
    code_reset();
    return 0;
}

int mapper_code_uninstall(void) {
    if (installed) {
        installed=0;
    }
    return 0;
}

void code_button(int code, int value) {
    if (!installed) return;
    if (value!=code_bit[code]) {
        press_joy_button(255, BTN_JOYSTICK+code, value);
        code_bit[code]=value;
    }
}

void code_axis(int axis, int value) {
    if (!installed) return;
    if (value!=code_analog[axis]) {
        set_joy_axis(255, axis, value);
        code_analog[axis]=value;
    }
}

void program_run() {
    int new_tick;

    if (started == 0)
        started = clock_millis();

    timestamp = clock_millis() - started;
    new_tick = timestamp / INTERVAL;

    if (tick != new_tick)
        clocktick=1;
    else
        clocktick=0;
    tick = new_tick;

    debug("timertick %d\n", timestamp);
    execute_script();
}