URL https://opencores.org/ocsvn/xulalx25soc/xulalx25soc/trunk

Subversion Repositories xulalx25soc

[/] [xulalx25soc/] [trunk/] [sw/] [ttybus.cpp] - Blame information for rev 11

Go to most recent revision | Details | Compare with Previous | View Log


////////////////////////////////////////////////////////////////////////////////
//
// Filename:    ttybus.cpp
//
// Project:     XuLA2 board
//
// Purpose:     This is the C++ program on the command side that will interact
//              with a UART on an FPGA, to command the WISHBONE on that same
//              FPGA to ... whatever we wish to command it to do.
//
//              This code does not run on an FPGA, is not a test bench, neither
//              is it a simulator.  It is a portion of a command program
//              for commanding an FPGA.
//
//
// Creator:     Dan Gisselquist, Ph.D.
//              Gisselquist Technology, LLC
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015, Gisselquist Technology, LLC
//
// This program is free software (firmware): 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 3 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 MERCHANTIBILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// for more details.
//
// License:     GPL, v3, as defined and found on www.gnu.org,
//              http://www.gnu.org/licenses/gpl.html
//
//
////////////////////////////////////////////////////////////////////////////////
//
//
//
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <arpa/inet.h> 
#include <assert.h> 
#include <strings.h> 
#include <poll.h> 
#include <ctype.h> 
 
#include "ttybus.h"
 
#define TTYC_IDLE       '0'
#define TTYC_BUSY       '1'
#define TTYC_WRITE      '2'
#define TTYC_RESET      '3'
#define TTYC_INT        '4'
#define TTYC_ERR        '5'
 
const   unsigned TTYBUS::MAXRDLEN = 1024;
const   unsigned TTYBUS::MAXWRLEN = 32;
 
// #define      DBGPRINTF       null
// #define      DBGPRINTF       printf
// void null(...) {}
#define DBGPRINTF       filedump
 
#include <stdarg.h>
// #include <varargs.h>
void    filedump(const char *fmt, ...) {
        static  FILE *dbgfp = NULL;
        va_list args;
 
        if (!dbgfp)
                dbgfp = fopen("debug.txt", "w");
        va_start(args, fmt);
        vfprintf(dbgfp, fmt, args);
        va_end(args);
        fflush(dbgfp);
}
 
char    TTYBUS::charenc(const int sixbitval) {
        if (sixbitval < 10)
                return '0' + sixbitval;
        else if (sixbitval < 10+26)
                return 'A' - 10 + sixbitval;
        else if (sixbitval < 10+26+26)
                return 'a' - 10 - 26 + sixbitval;
        else if (sixbitval == 0x3e)
                return '@';
        else if (sixbitval == 0x3f)
                return '%';
 
        fprintf(stderr, "INTERNAL ERR: SIXBITVAL isn\'t!!!! sixbitval = %08x\n", sixbitval);
        assert((sixbitval & (~0x03f))==0);
        return 0;
}
 
unsigned        TTYBUS::chardec(const char b) {
        if ((b >= '0')&&(b <= '9'))
                return b-'0';
        else if ((b >= 'A')&&(b <= 'Z'))
                return b-'A'+10;
        else if ((b >= 'a')&&(b <= 'z'))
                return b-'a'+36;
        else if (b == '@')
                return 0x03e;
        else if (b == '%')
                return 0x03f;
        else
                return 0x0100; // ERR -- invalid code
}
 
int     TTYBUS::lclreadcode(char *buf, int len) {
        char    *sp, *dp;
        int     nr, ret;
 
        nr = m_dev->read(buf, len);
        m_total_nread += nr;
        ret = nr; sp = buf; dp = buf;
        for(int i=0; i<nr; i++) {
                if (chardec(*sp)&(~0x3f)) {
                        ret--;  // Skip this value, not a valid codeword
                        sp++;
                } else {
                        *sp++ = *dp++;
                }
        } return ret;
}
 
void    TTYBUS::bufalloc(int len) {
        if ((m_buf)&&(m_buflen >= len))
                return;
        if (m_buf)
                delete[] m_buf;
        m_buflen = (len&(-0x3f))+0x40;
        m_buf = new char[m_buflen];
}
 
void    TTYBUS::encode(const int hb, const BUSW val, char *buf) {
        buf[0] = charenc( (hb<<2)|((val>>30)&0x03) );
        buf[1] = charenc( (val>>24)&0x3f);
        buf[2] = charenc( (val>>18)&0x3f);
        buf[3] = charenc( (val>>12)&0x3f);
        buf[4] = charenc( (val>> 6)&0x3f);
        buf[5] = charenc( (val    )&0x3f);
}
 
unsigned        TTYBUS::decodestr(const char *buf) {
        unsigned        r;
 
        r = chardec(buf[0]) & 0x03;
        r = (r<<6) | (chardec(buf[1]) & 0x03f);
        r = (r<<6) | (chardec(buf[2]) & 0x03f);
        r = (r<<6) | (chardec(buf[3]) & 0x03f);
        r = (r<<6) | (chardec(buf[4]) & 0x03f);
        r = (r<<6) | (chardec(buf[5]) & 0x03f);
 
        return r;
}
 
int     TTYBUS::decodehex(const char hx) {
        if ((hx >= '0')&&(hx <= '9'))
                return hx-'0';
        else if ((hx >= 'A')&&(hx <= 'Z'))
                return hx-'A'+10;
        else if ((hx >= 'a')&&(hx <= 'z'))
                return hx-'a'+10;
        else
                return 0;
}
 
void    TTYBUS::writeio(const BUSW a, const BUSW v) {
 
        writev(a, 0, 1, &v);
        m_lastaddr = a; m_addr_set = true;
}
 
void    TTYBUS::writev(const BUSW a, const int p, const int len, const BUSW *buf) {
        char    *ptr;
 
        // Allocate a buffer of six bytes per word, one for addr, plus
        // six more
        bufalloc((len+2)*6);
 
        DBGPRINTF("WRITEV(%08x,%d,#%d,0x%08x ...)\n", a, p, len, buf[0]);
        // Encode the address
        ptr = encode_address(a);
        m_lastaddr = a; m_addr_set = true;
 
        for(int i=0; i<len; i++) {
                BUSW    val = buf[i];
 
                int     caddr = 0;
                // Let's try compression
                for(int i=1; i<256; i++) {
                        unsigned        tstaddr;
                        tstaddr = (m_wraddr - i) & 0x0ff;
                        if ((!m_wrloaded)&&(tstaddr > (unsigned)m_wraddr))
                                break;
                        if (m_writetbl[tstaddr] == val) {
                                caddr = ( m_wraddr- tstaddr ) & 0x0ff;
                                break;
                        }
                }
 
                if (caddr != 0)
                        DBGPRINTF("WR[%08x] = %08x (= TBL[%4x] <= %4x)\n", m_lastaddr, val, caddr, m_wraddr);
                else
                        DBGPRINTF("WR[%08x] = %08x\n", m_lastaddr, val);
 
                if (caddr != 0) {
                        *ptr++ = charenc( (((caddr>>6)&0x03)<<1) + (p?1:0) + 0x010);
                        *ptr++ = charenc(    caddr    &0x3f    );
 
                } else {
                        // For testing, let's start just doing this the hard way
                        *ptr++ = charenc( (((val>>30)&0x03)<<1) + (p?1:0) + 0x018);
                        *ptr++ = charenc( (val>>24)&0x3f);
                        *ptr++ = charenc( (val>>18)&0x3f);
                        *ptr++ = charenc( (val>>12)&0x3f);
                        *ptr++ = charenc( (val>> 6)&0x3f);
                        *ptr++ = charenc( (val    )&0x3f);
 
                        m_writetbl[m_wraddr++] = val;
                        m_wraddr &= 0x0ff;
                        if (m_wraddr == 0) {
                                m_wrloaded = true;
                        }
                }
 
                if (p == 1) m_lastaddr++;
        }
        // *ptr++ = charenc(0x2e);
        *ptr++ = '\n'; *ptr = '\0';
        m_dev->write(m_buf, ptr-m_buf);
 
        DBGPRINTF(">> %s\n", m_buf);
        DBGPRINTF("WR: LAST ADDRESS LEFT AT %08x\n", m_lastaddr);
}
 
void    TTYBUS::writez(const BUSW a, const int len, const BUSW *buf) {
        int     ln = len;
        const TTYBUS::BUSW *bptr = buf;
        TTYBUS::BUSW addr = a;
 
        while((unsigned)ln > MAXWRLEN) {
                writev(addr, 0, MAXWRLEN, bptr);
                bptr += MAXWRLEN;
                ln   -= MAXWRLEN;
                // addr += MAXWRLEN;
        } if ((unsigned)ln > 0)
                writev(addr, 0, ln, bptr);
}
 
void    TTYBUS::writei(const BUSW a, const int len, const BUSW *buf) {
        int     ln = len;
        const TTYBUS::BUSW *bptr = buf;
        TTYBUS::BUSW addr = a;
 
        while((unsigned)ln > MAXWRLEN) {
                writev(addr, 1, MAXWRLEN, bptr);
                bptr += MAXWRLEN;
                ln   -= MAXWRLEN;
                addr += MAXWRLEN;
        } if ((unsigned)ln > 0)
                writev(addr, 1, ln, bptr);
}
 
TTYBUS::BUSW    TTYBUS::readio(const TTYBUS::BUSW a) {
        BUSW    v;
 
        // I/O reads are now the same as vector reads, but with a vector length
        // of one.
        DBGPRINTF("READIO(0x%08x)\n", a);
        try {
                readv(a, 0, 1, &v);
        } catch(BUSERR b) {
                throw BUSERR(a);
        }
 
        if (m_lastaddr != a) {
                DBGPRINTF("LAST-ADDR MIS-MATCH: (RCVD) %08x != %08x (XPECTED)\n", m_lastaddr, a);
                m_addr_set = false;
 
                exit(-3);
        }
 
        return v;
}
 
char    *TTYBUS::encode_address(const TTYBUS::BUSW a) {
        TTYBUS::BUSW    addr = a;
        char    *ptr = m_buf;
 
        if ((m_addr_set)&&(a == m_lastaddr))
                return ptr;
 
        if (m_addr_set) {
                // Encode a difference address
                int     diffaddr = addr - m_lastaddr;
                ptr = m_buf;
                if ((diffaddr >= -32)&&(diffaddr < 32)) {
                        *ptr++ = charenc(0x09);
                        *ptr++ = charenc(diffaddr & 0x03f);
                } else if ((diffaddr >= -2048)&&(diffaddr < 2048)) {
                        *ptr++ = charenc(0x0b);
                        *ptr++ = charenc((diffaddr>>6) & 0x03f);
                        *ptr++ = charenc( diffaddr     & 0x03f);
                } else if ((diffaddr >= -(1<<17))&&(diffaddr < (1<<17))) {
                        *ptr++ = charenc(0x0d);
                        *ptr++ = charenc((diffaddr>>12) & 0x03f);
                        *ptr++ = charenc((diffaddr>> 6) & 0x03f);
                        *ptr++ = charenc( diffaddr      & 0x03f);
                } else if ((diffaddr >= -(1<<23))&&(diffaddr < (1<<23))) {
                        *ptr++ = charenc(0x0d);
                        *ptr++ = charenc((diffaddr>>18) & 0x03f);
                        *ptr++ = charenc((diffaddr>>12) & 0x03f);
                        *ptr++ = charenc((diffaddr>> 6) & 0x03f);
                        *ptr++ = charenc( diffaddr      & 0x03f);
                }
                *ptr = '\0';
                DBGPRINTF("DIF-ADDR: (%ld) \'%s\'\n", ptr-m_buf, m_buf);
        }
 
        {
                // Encode an absolute (low memory) address
                // Prefer absolute address encoding over differential encoding,
                // when both encodings encode the same address, and when both
                // encode the address in the same number of words
                if ((addr <= 0x03f)&&((ptr == m_buf)||(ptr >= &m_buf[2]))) {
                        ptr = m_buf;
                        *ptr++ = charenc(0x08);
                        *ptr++ = charenc(addr);
                } else if((addr <= 0x0fff)&&((ptr == m_buf)||(ptr >= &m_buf[3]))) {
                        DBGPRINTF("Setting ADDR.3 to %08x\n", addr);
                        ptr = m_buf;
                        *ptr++ = charenc(0x0a);
                        *ptr++ = charenc((addr>> 6) & 0x03f);
                        *ptr++ = charenc( addr      & 0x03f);
                } else if((addr <= 0x03ffff)&&((ptr == m_buf)||(ptr >= &m_buf[4]))) {
                        DBGPRINTF("Setting ADDR.4 to %08x\n", addr);
                        ptr = m_buf;
                        *ptr++ = charenc(0x0c);
                        *ptr++ = charenc((addr>>12) & 0x03f);
                        *ptr++ = charenc((addr>> 6) & 0x03f);
                        *ptr++ = charenc( addr      & 0x03f);
                } else if((addr <= 0x0ffffff)&&((ptr == m_buf)||(ptr >= &m_buf[5]))) {
                        DBGPRINTF("Setting ADDR.5 to %08x\n", addr);
                        ptr = m_buf;
                        *ptr++ = charenc(0x0e);
                        *ptr++ = charenc((addr>>18) & 0x03f);
                        *ptr++ = charenc((addr>>12) & 0x03f);
                        *ptr++ = charenc((addr>> 6) & 0x03f);
                        *ptr++ = charenc( addr      & 0x03f);
                } else if (ptr == m_buf) { // Send our address prior to any read
                        ptr = m_buf;
                        encode(0, addr, ptr);
                        ptr+=6;
                }
        }
 
        *ptr = '\0';
        DBGPRINTF("ADDR-CMD: (%ld) \'%s\'\n", ptr-m_buf, m_buf);
        m_rdaddr = 0;
 
        return ptr;
}
 
char    *TTYBUS::readcmd(const int inc, const int len, char *buf) {
        char    *ptr = buf;
 
        DBGPRINTF("READCMD: LEN = %d\n", len);
        assert(len < 520);
        assert(len > 0);
 
        if ((len < 8)||((len == 8)&&(inc))) {
                *ptr++ = charenc(0x20 + (((len-1)&0x07)<<1) + (inc?1:0));
        } else {
                *ptr++ = charenc(0x30 + (((len-8)>>5)&0x0e) + (inc?1:0));
                *ptr++ = charenc( (len-8) & 0x03f);
        }
 
        return ptr;
}
 
void    TTYBUS::readv(const TTYBUS::BUSW a, const int inc, const int len, TTYBUS::BUSW *buf) {
        const   int     READAHEAD = MAXRDLEN/2, READBLOCK=MAXRDLEN/2;
        int     cmdrd = 0, nread = 0;
        // TTYBUS::BUSW addr = a;
        char    *ptr = m_buf;
 
        if (len <= 0)
                return;
        DBGPRINTF("READV(%08x,%d,#%4d)\n", a, inc, len);
 
        ptr = encode_address(a);
        try {
            while(cmdrd < len) {
                // ptr = m_buf;
                do {
                        int     nrd = len-cmdrd;
                        if (nrd > READBLOCK)
                                nrd = READBLOCK;
                        if (cmdrd-nread + nrd>READAHEAD+READBLOCK)
                                nrd = READAHEAD+READBLOCK-(cmdrd-nread);
                        ptr = readcmd(inc, nrd, ptr);
                        cmdrd += nrd;
                } while((cmdrd-nread < READAHEAD+READBLOCK)&&(cmdrd< len));
 
                *ptr++ = '\n'; *ptr = '\0';
                m_dev->write(m_buf, (ptr-m_buf));
 
                while(nread<(cmdrd-READAHEAD)) {
                        buf[nread++] = readword();
                } ptr = m_buf;
            } while(nread<len) {
                buf[nread++] = readword();
            }
        } catch(BUSERR b) {
                throw BUSERR(a+((inc)?nread:0));
        }
 
        if ((unsigned)m_lastaddr != (a+((inc)?(len):0))) {
                DBGPRINTF("TTYBUS::READV(a=%08x,inc=%d,len=%4x,x) ERR: (Last) %08x != %08x + %08x (Expected)\n", a, inc, len, m_lastaddr, a, (inc)?(len):0);
                printf("TTYBUS::READV(a=%08x,inc=%d,len=%4x,x) ERR: (Last) %08x != %08x + %08x (Expected)\n", a, inc, len, m_lastaddr, a, (inc)?(len):0);
                sleep(1);
                assert((int)m_lastaddr == (a+(inc)?(len):0));
                exit(-3);
        }
}
 
void    TTYBUS::readi(const TTYBUS::BUSW a, const int len, TTYBUS::BUSW *buf) {
        readv(a, 1, len, buf);
}
 
void    TTYBUS::readz(const TTYBUS::BUSW a, const int len, TTYBUS::BUSW *buf) {
        readv(a, 0, len, buf);
}
 
TTYBUS::BUSW    TTYBUS::readword(void) {
        TTYBUS::BUSW    val = 0;
        int             nr;
        unsigned        sixbits;
 
        DBGPRINTF("READ-WORD()\n");
 
        bool    found_start = false;
        do {
                // Blocking read (for now)
                do {
                        nr = lclreadcode(&m_buf[0], 1);
                } while (nr < 1);
 
                sixbits = chardec(m_buf[0]);
 
                if (sixbits&(~0x03f)) {
                        // Ignore new lines, unprintables, and characters
                        // not a part of our code
                        ;
                } else if (sixbits < 6) {
                        switch(sixbits) {
                        case 0:  break; // Idle -- ignore
                        case 1: break; // Idle, but the bus is busy
                        case 2: break; // Write acknowledgement, ignore it here
                        case 3:
                                m_bus_err = true;
                                throw BUSERR(0);
                                break;
                        case 4:
                                m_interrupt_flag = true;
                                break;
                        case 5:
                                m_bus_err = true;
                                throw BUSERR(0);
                                break;
                        }
                } else if (0x08 == (sixbits & 0x3c)) { // Set 32-bit address
                        do {
                                nr += lclreadcode(&m_buf[nr], 6-nr);
                        } while (nr < 6);
 
                        val = chardec(m_buf[0]) & 0x03;
                        val = (val<<6) | (chardec(m_buf[1]) & 0x03f);
                        val = (val<<6) | (chardec(m_buf[2]) & 0x03f);
                        val = (val<<6) | (chardec(m_buf[3]) & 0x03f);
                        val = (val<<6) | (chardec(m_buf[4]) & 0x03f);
                        val = (val<<6) | (chardec(m_buf[5]) & 0x03f);
 
                        m_addr_set = true;
                        m_lastaddr = val;
 
                        DBGPRINTF("RCVD ADDR: 0x%08x\n", val);
                } else if (0x0c == (sixbits & 0x03c)) { // Set 32-bit address,compressed
                        int nw = (sixbits & 0x03) + 2;
                        do {
                                nr += lclreadcode(&m_buf[nr], nw-nr);
                        } while (nr < nw);
 
                        if (nw == 2) {
                                val = chardec(m_buf[1]);
                        } else if (nw == 3) {
                                val = chardec(m_buf[1]);
                                val = (val<<6) | (chardec(m_buf[2]) & 0x03f);
                        } else if (nw == 4) {
                                val = chardec(m_buf[1]);
                                val = (val<<6) | (chardec(m_buf[2]) & 0x03f);
                                val = (val<<6) | (chardec(m_buf[3]) & 0x03f);
                        } else { // if (nw == 5)
                                val = chardec(m_buf[1]);
                                val = (val<<6) | (chardec(m_buf[2]) & 0x03f);
                                val = (val<<6) | (chardec(m_buf[3]) & 0x03f);
                                val = (val<<6) | (chardec(m_buf[4]) & 0x03f);
                        }
 
                        m_addr_set = true;
                        m_lastaddr = val;
                        DBGPRINTF("RCVD ADDR: 0x%08x (%d bytes)\n", val, nw+1);
                } else
                        found_start = true;
        } while(!found_start);
 
        int     rdaddr;
 
        if (0x06 == (sixbits & 0x03e)) { // Tbl read, last value
                rdaddr = (m_rdaddr-1)&0x03ff;
                val = m_readtbl[rdaddr];
                m_lastaddr += (sixbits&1);
        } else if (0x10 == (sixbits & 0x030)) { // Tbl read, up to 521 into past
                int     idx;
                do {
                        nr += lclreadcode(&m_buf[nr], 2-nr);
                } while (nr < 2);
 
                idx = (chardec(m_buf[0])>>1) & 0x07;
                idx = ((idx<<6) | (chardec(m_buf[1]) & 0x03f)) + 2 + 8;
                rdaddr = (m_rdaddr-idx)&0x03ff;
                val = m_readtbl[rdaddr];
                m_lastaddr += (sixbits&1);
        } else if (0x20 == (sixbits & 0x030)) { // Tbl read, 2-9 into past
                rdaddr = (m_rdaddr - (((sixbits>>1)&0x07)+2)) & 0x03ff;
                val = m_readtbl[rdaddr];
                m_lastaddr += (sixbits&1);
        } else if (0x38 == (sixbits & 0x038)) { // Raw read
                do {
                        nr += lclreadcode(&m_buf[nr], 6-nr);
                } while (nr < 6);
 
                val = (chardec(m_buf[0])>>1) & 0x03;
                val = (val<<6) | (chardec(m_buf[1]) & 0x03f);
                val = (val<<6) | (chardec(m_buf[2]) & 0x03f);
                val = (val<<6) | (chardec(m_buf[3]) & 0x03f);
                val = (val<<6) | (chardec(m_buf[4]) & 0x03f);
                val = (val<<6) | (chardec(m_buf[5]) & 0x03f);
 
                m_readtbl[m_rdaddr++] = val; m_rdaddr &= 0x03ff;
                m_lastaddr += (sixbits&1);
        }
 
        return val;
}
 
void    TTYBUS::usleep(unsigned ms) {
        if (m_dev->poll(ms)) {
                int     nr;
                nr = m_dev->read(m_buf, 16);
                if (nr == 0) {
                        // Connection closed, let it drop
                        DBGPRINTF("Connection closed!!\n");
                        m_dev->close();
                        exit(-1);
                } for(int i=0; i<nr; i++) {
                        if (m_buf[i] == TTYC_INT) {
                                m_interrupt_flag = true;
                                DBGPRINTF("!!!!!!!!!!!!!!!!! ----- INTERRUPT!\n");
                        } else if (m_buf[i] == TTYC_IDLE) {
                                DBGPRINTF("Interface is now idle\n");
                        } else if (m_buf[i] == TTYC_WRITE) {
                        } else if (m_buf[i] == TTYC_RESET) {
                                DBGPRINTF("Bus was RESET!\n");
                        } else if (m_buf[i] == TTYC_ERR) {
                                DBGPRINTF("Bus error\n");
                        } else if (m_buf[i] == TTYC_BUSY) {
                                DBGPRINTF("Interface is ... busy ??\n");
                        }
                        // else if (m_buf[nr] == 'Q')
                        // else if (m_buf[nr] == 'W')
                        // else if (m_buf[nr] == '\n')
                }
        }
}
 
void    TTYBUS::wait(void) {
        if (m_interrupt_flag)
                DBGPRINTF("INTERRUPTED PRIOR TO WAIT()\n");
        do {
                usleep(200);
        } while(!m_interrupt_flag);
}
 
// TTYBUS:  3503421 ~= 3.3 MB, stopwatch = 1:18.5 seconds, vs 53.8 secs
//      If you issue two 512 word reads at once, time drops to 41.6 secs.
// PORTBUS: 6408320 ~= 6.1 MB, ... 26% improvement, 53 seconds real time
 

Browse

Tools

Subversion Repositories xulalx25soc

[/] [xulalx25soc/] [trunk/] [sw/] [ttybus.cpp] - Blame information for rev 11

Line No.	Rev	Author	Line
1	5	dgisselq	`////////////////////////////////////////////////////////////////////////////////`
2			`//`
3			`// Filename: ttybus.cpp`
4			`//`
5			`// Project: XuLA2 board`
6			`//`
7			`// Purpose: This is the C++ program on the command side that will interact`
8			`// with a UART on an FPGA, to command the WISHBONE on that same`
9			`// FPGA to ... whatever we wish to command it to do.`
10			`//`
11			`// This code does not run on an FPGA, is not a test bench, neither`
12			`// is it a simulator. It is a portion of a command program`
13			`// for commanding an FPGA.`
14			`//`
15			`//`
16			`// Creator: Dan Gisselquist, Ph.D.`
17			`// Gisselquist Technology, LLC`
18			`//`
19			`////////////////////////////////////////////////////////////////////////////////`
20			`//`
21			`// Copyright (C) 2015, Gisselquist Technology, LLC`
22			`//`
23			`// This program is free software (firmware): you can redistribute it and/or`
24			`// modify it under the terms of the GNU General Public License as published`
25			`// by the Free Software Foundation, either version 3 of the License, or (at`
26			`// your option) any later version.`
27			`//`
28			`// This program is distributed in the hope that it will be useful, but WITHOUT`
29			`// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or`
30			`// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License`
31			`// for more details.`
32			`//`
33			`// License: GPL, v3, as defined and found on www.gnu.org,`
34			`// http://www.gnu.org/licenses/gpl.html`
35			`//`
36			`//`
37			`////////////////////////////////////////////////////////////////////////////////`
38			`//`
39			`//`
40			`//`
41			`#include <sys/socket.h>`
42			`#include <sys/types.h>`
43			`#include <sys/stat.h>`
44			`#include <fcntl.h>`
45			`#include <termios.h>`
46			`#include <netinet/in.h>`
47			`#include <netdb.h>`
48			`#include <stdio.h>`
49			`#include <string.h>`
50			`#include <stdlib.h>`
51			`#include <unistd.h>`
52			`#include <errno.h>`
53			`#include <arpa/inet.h>`
54			`#include <assert.h>`
55			`#include <strings.h>`
56			`#include <poll.h>`
57			`#include <ctype.h>`
58
59			`#include "ttybus.h"`
60
61			`#define TTYC_IDLE '0'`
62			`#define TTYC_BUSY '1'`
63			`#define TTYC_WRITE '2'`
64			`#define TTYC_RESET '3'`
65			`#define TTYC_INT '4'`
66			`#define TTYC_ERR '5'`
67
68			`const unsigned TTYBUS::MAXRDLEN = 1024;`
69			`const unsigned TTYBUS::MAXWRLEN = 32;`
70
71	11	dgisselq	`// #define DBGPRINTF null`
72	5	dgisselq	`// #define DBGPRINTF printf`
73	11	dgisselq	`// void null(...) {}`
74			`#define DBGPRINTF filedump`
75	5	dgisselq
76	11	dgisselq	`#include <stdarg.h>`
77			`// #include <varargs.h>`
78			`void filedump(const char *fmt, ...) {`
79			`static FILE *dbgfp = NULL;`
80			`va_list args;`
81
82			`if (!dbgfp)`
83			`dbgfp = fopen("debug.txt", "w");`
84			`va_start(args, fmt);`
85			`vfprintf(dbgfp, fmt, args);`
86			`va_end(args);`
87			`fflush(dbgfp);`
88			`}`
89
90	5	dgisselq	`char TTYBUS::charenc(const int sixbitval) {`
91			`if (sixbitval < 10)`
92			`return '0' + sixbitval;`
93			`else if (sixbitval < 10+26)`
94			`return 'A' - 10 + sixbitval;`
95			`else if (sixbitval < 10+26+26)`
96			`return 'a' - 10 - 26 + sixbitval;`
97			`else if (sixbitval == 0x3e)`
98			`return '@';`
99			`else if (sixbitval == 0x3f)`
100			`return '%';`
101
102			`fprintf(stderr, "INTERNAL ERR: SIXBITVAL isn\'t!!!! sixbitval = %08x\n", sixbitval);`
103			`assert((sixbitval & (~0x03f))==0);`
104			`return 0;`
105			`}`
106
107			`unsigned TTYBUS::chardec(const char b) {`
108			`if ((b >= '0')&&(b <= '9'))`
109			`return b-'0';`
110			`else if ((b >= 'A')&&(b <= 'Z'))`
111			`return b-'A'+10;`
112			`else if ((b >= 'a')&&(b <= 'z'))`
113			`return b-'a'+36;`
114			`else if (b == '@')`
115			`return 0x03e;`
116			`else if (b == '%')`
117			`return 0x03f;`
118			`else`
119			`return 0x0100; // ERR -- invalid code`
120			`}`
121
122			`int TTYBUS::lclreadcode(char *buf, int len) {`
123			`char sp, dp;`
124			`int nr, ret;`
125
126			`nr = m_dev->read(buf, len);`
127			`m_total_nread += nr;`
128			`ret = nr; sp = buf; dp = buf;`
129			`for(int i=0; i<nr; i++) {`
130			`if (chardec(*sp)&(~0x3f)) {`
131			`ret--; // Skip this value, not a valid codeword`
132			`sp++;`
133			`} else {`
134			`sp++ = dp++;`
135			`}`
136			`} return ret;`
137			`}`
138
139			`void TTYBUS::bufalloc(int len) {`
140			`if ((m_buf)&&(m_buflen >= len))`
141			`return;`
142			`if (m_buf)`
143			`delete[] m_buf;`
144			`m_buflen = (len&(-0x3f))+0x40;`
145			`m_buf = new char[m_buflen];`
146			`}`
147
148			`void TTYBUS::encode(const int hb, const BUSW val, char *buf) {`
149			`buf[0] = charenc( (hb<<2)\|((val>>30)&0x03) );`
150			`buf[1] = charenc( (val>>24)&0x3f);`
151			`buf[2] = charenc( (val>>18)&0x3f);`
152			`buf[3] = charenc( (val>>12)&0x3f);`
153			`buf[4] = charenc( (val>> 6)&0x3f);`
154			`buf[5] = charenc( (val )&0x3f);`
155			`}`
156
157			`unsigned TTYBUS::decodestr(const char *buf) {`
158			`unsigned r;`
159
160			`r = chardec(buf[0]) & 0x03;`
161			`r = (r<<6) \| (chardec(buf[1]) & 0x03f);`
162			`r = (r<<6) \| (chardec(buf[2]) & 0x03f);`
163			`r = (r<<6) \| (chardec(buf[3]) & 0x03f);`
164			`r = (r<<6) \| (chardec(buf[4]) & 0x03f);`
165			`r = (r<<6) \| (chardec(buf[5]) & 0x03f);`
166
167			`return r;`
168			`}`
169
170			`int TTYBUS::decodehex(const char hx) {`
171			`if ((hx >= '0')&&(hx <= '9'))`
172			`return hx-'0';`
173			`else if ((hx >= 'A')&&(hx <= 'Z'))`
174			`return hx-'A'+10;`
175			`else if ((hx >= 'a')&&(hx <= 'z'))`
176			`return hx-'a'+10;`
177			`else`
178			`return 0;`
179			`}`
180
181			`void TTYBUS::writeio(const BUSW a, const BUSW v) {`
182
183			`writev(a, 0, 1, &v);`
184			`m_lastaddr = a; m_addr_set = true;`
185			`}`
186
187			`void TTYBUS::writev(const BUSW a, const int p, const int len, const BUSW *buf) {`
188			`char *ptr;`
189
190			`// Allocate a buffer of six bytes per word, one for addr, plus`
191			`// six more`
192			`bufalloc((len+2)*6);`
193
194			`DBGPRINTF("WRITEV(%08x,%d,#%d,0x%08x ...)\n", a, p, len, buf[0]);`
195			`// Encode the address`
196			`ptr = encode_address(a);`
197			`m_lastaddr = a; m_addr_set = true;`
198
199			`for(int i=0; i<len; i++) {`
200			`BUSW val = buf[i];`
201
202			`int caddr = 0;`
203			`// Let's try compression`
204			`for(int i=1; i<256; i++) {`
205			`unsigned tstaddr;`
206			`tstaddr = (m_wraddr - i) & 0x0ff;`
207			`if ((!m_wrloaded)&&(tstaddr > (unsigned)m_wraddr))`
208			`break;`
209			`if (m_writetbl[tstaddr] == val) {`
210			`caddr = ( m_wraddr- tstaddr ) & 0x0ff;`
211			`break;`
212			`}`
213			`}`
214
215			`if (caddr != 0)`
216			`DBGPRINTF("WR[%08x] = %08x (= TBL[%4x] <= %4x)\n", m_lastaddr, val, caddr, m_wraddr);`
217			`else`
218			`DBGPRINTF("WR[%08x] = %08x\n", m_lastaddr, val);`
219
220			`if (caddr != 0) {`
221			`*ptr++ = charenc( (((caddr>>6)&0x03)<<1) + (p?1:0) + 0x010);`
222			`*ptr++ = charenc( caddr &0x3f );`
223
224			`} else {`
225			`// For testing, let's start just doing this the hard way`
226			`*ptr++ = charenc( (((val>>30)&0x03)<<1) + (p?1:0) + 0x018);`
227			`*ptr++ = charenc( (val>>24)&0x3f);`
228			`*ptr++ = charenc( (val>>18)&0x3f);`
229			`*ptr++ = charenc( (val>>12)&0x3f);`
230			`*ptr++ = charenc( (val>> 6)&0x3f);`
231			`*ptr++ = charenc( (val )&0x3f);`
232
233			`m_writetbl[m_wraddr++] = val;`
234			`m_wraddr &= 0x0ff;`
235			`if (m_wraddr == 0) {`
236			`m_wrloaded = true;`
237			`}`
238			`}`
239
240			`if (p == 1) m_lastaddr++;`
241			`}`
242			`// *ptr++ = charenc(0x2e);`
243			`ptr++ = '\n'; ptr = '\0';`
244			`m_dev->write(m_buf, ptr-m_buf);`
245
246			`DBGPRINTF(">> %s\n", m_buf);`
247			`DBGPRINTF("WR: LAST ADDRESS LEFT AT %08x\n", m_lastaddr);`
248			`}`
249
250			`void TTYBUS::writez(const BUSW a, const int len, const BUSW *buf) {`
251			`int ln = len;`
252			`const TTYBUS::BUSW *bptr = buf;`
253			`TTYBUS::BUSW addr = a;`
254
255			`while((unsigned)ln > MAXWRLEN) {`
256			`writev(addr, 0, MAXWRLEN, bptr);`
257			`bptr += MAXWRLEN;`
258			`ln -= MAXWRLEN;`
259			`// addr += MAXWRLEN;`
260			`} if ((unsigned)ln > 0)`
261			`writev(addr, 0, ln, bptr);`
262			`}`
263
264			`void TTYBUS::writei(const BUSW a, const int len, const BUSW *buf) {`
265			`int ln = len;`
266			`const TTYBUS::BUSW *bptr = buf;`
267			`TTYBUS::BUSW addr = a;`
268
269			`while((unsigned)ln > MAXWRLEN) {`
270			`writev(addr, 1, MAXWRLEN, bptr);`
271			`bptr += MAXWRLEN;`
272			`ln -= MAXWRLEN;`
273			`addr += MAXWRLEN;`
274			`} if ((unsigned)ln > 0)`
275			`writev(addr, 1, ln, bptr);`
276			`}`
277
278			`TTYBUS::BUSW TTYBUS::readio(const TTYBUS::BUSW a) {`
279			`BUSW v;`
280
281			`// I/O reads are now the same as vector reads, but with a vector length`
282			`// of one.`
283	11	dgisselq	`DBGPRINTF("READIO(0x%08x)\n", a);`
284	5	dgisselq	`try {`
285			`readv(a, 0, 1, &v);`
286			`} catch(BUSERR b) {`
287			`throw BUSERR(a);`
288			`}`
289
290			`if (m_lastaddr != a) {`
291			`DBGPRINTF("LAST-ADDR MIS-MATCH: (RCVD) %08x != %08x (XPECTED)\n", m_lastaddr, a);`
292			`m_addr_set = false;`
293
294			`exit(-3);`
295			`}`
296
297			`return v;`
298			`}`
299
300			`char *TTYBUS::encode_address(const TTYBUS::BUSW a) {`
301			`TTYBUS::BUSW addr = a;`
302			`char *ptr = m_buf;`
303
304			`if ((m_addr_set)&&(a == m_lastaddr))`
305			`return ptr;`
306
307			`if (m_addr_set) {`
308			`// Encode a difference address`
309			`int diffaddr = addr - m_lastaddr;`
310			`ptr = m_buf;`
311			`if ((diffaddr >= -32)&&(diffaddr < 32)) {`
312			`*ptr++ = charenc(0x09);`
313			`*ptr++ = charenc(diffaddr & 0x03f);`
314			`} else if ((diffaddr >= -2048)&&(diffaddr < 2048)) {`
315			`*ptr++ = charenc(0x0b);`
316			`*ptr++ = charenc((diffaddr>>6) & 0x03f);`
317			`*ptr++ = charenc( diffaddr & 0x03f);`
318			`} else if ((diffaddr >= -(1<<17))&&(diffaddr < (1<<17))) {`
319			`*ptr++ = charenc(0x0d);`
320			`*ptr++ = charenc((diffaddr>>12) & 0x03f);`
321			`*ptr++ = charenc((diffaddr>> 6) & 0x03f);`
322			`*ptr++ = charenc( diffaddr & 0x03f);`
323			`} else if ((diffaddr >= -(1<<23))&&(diffaddr < (1<<23))) {`
324			`*ptr++ = charenc(0x0d);`
325			`*ptr++ = charenc((diffaddr>>18) & 0x03f);`
326			`*ptr++ = charenc((diffaddr>>12) & 0x03f);`
327			`*ptr++ = charenc((diffaddr>> 6) & 0x03f);`
328			`*ptr++ = charenc( diffaddr & 0x03f);`
329			`}`
330			`*ptr = '\0';`
331	11	dgisselq	`DBGPRINTF("DIF-ADDR: (%ld) \'%s\'\n", ptr-m_buf, m_buf);`
332	5	dgisselq	`}`
333
334			`{`
335			`// Encode an absolute (low memory) address`
336			`// Prefer absolute address encoding over differential encoding,`
337			`// when both encodings encode the same address, and when both`
338			`// encode the address in the same number of words`
339			`if ((addr <= 0x03f)&&((ptr == m_buf)\|\|(ptr >= &m_buf[2]))) {`
340			`ptr = m_buf;`
341			`*ptr++ = charenc(0x08);`
342			`*ptr++ = charenc(addr);`
343			`} else if((addr <= 0x0fff)&&((ptr == m_buf)\|\|(ptr >= &m_buf[3]))) {`
344	11	dgisselq	`DBGPRINTF("Setting ADDR.3 to %08x\n", addr);`
345	5	dgisselq	`ptr = m_buf;`
346			`*ptr++ = charenc(0x0a);`
347			`*ptr++ = charenc((addr>> 6) & 0x03f);`
348			`*ptr++ = charenc( addr & 0x03f);`
349			`} else if((addr <= 0x03ffff)&&((ptr == m_buf)\|\|(ptr >= &m_buf[4]))) {`
350	11	dgisselq	`DBGPRINTF("Setting ADDR.4 to %08x\n", addr);`
351	5	dgisselq	`ptr = m_buf;`
352			`*ptr++ = charenc(0x0c);`
353			`*ptr++ = charenc((addr>>12) & 0x03f);`
354			`*ptr++ = charenc((addr>> 6) & 0x03f);`
355			`*ptr++ = charenc( addr & 0x03f);`
356			`} else if((addr <= 0x0ffffff)&&((ptr == m_buf)\|\|(ptr >= &m_buf[5]))) {`
357	11	dgisselq	`DBGPRINTF("Setting ADDR.5 to %08x\n", addr);`
358	5	dgisselq	`ptr = m_buf;`
359			`*ptr++ = charenc(0x0e);`
360			`*ptr++ = charenc((addr>>18) & 0x03f);`
361			`*ptr++ = charenc((addr>>12) & 0x03f);`
362			`*ptr++ = charenc((addr>> 6) & 0x03f);`
363			`*ptr++ = charenc( addr & 0x03f);`
364			`} else if (ptr == m_buf) { // Send our address prior to any read`
365			`ptr = m_buf;`
366			`encode(0, addr, ptr);`
367			`ptr+=6;`
368			`}`
369			`}`
370
371			`*ptr = '\0';`
372	11	dgisselq	`DBGPRINTF("ADDR-CMD: (%ld) \'%s\'\n", ptr-m_buf, m_buf);`
373	5	dgisselq	`m_rdaddr = 0;`
374
375			`return ptr;`
376			`}`
377
378			`char TTYBUS::readcmd(const int inc, const int len, char buf) {`
379			`char *ptr = buf;`
380
381	11	dgisselq	`DBGPRINTF("READCMD: LEN = %d\n", len);`
382	5	dgisselq	`assert(len < 520);`
383			`assert(len > 0);`
384
385			`if ((len < 8)\|\|((len == 8)&&(inc))) {`
386			`*ptr++ = charenc(0x20 + (((len-1)&0x07)<<1) + (inc?1:0));`
387			`} else {`
388			`*ptr++ = charenc(0x30 + (((len-8)>>5)&0x0e) + (inc?1:0));`
389			`*ptr++ = charenc( (len-8) & 0x03f);`
390			`}`
391
392			`return ptr;`
393			`}`
394
395			`void TTYBUS::readv(const TTYBUS::BUSW a, const int inc, const int len, TTYBUS::BUSW *buf) {`
396			`const int READAHEAD = MAXRDLEN/2, READBLOCK=MAXRDLEN/2;`
397			`int cmdrd = 0, nread = 0;`
398			`// TTYBUS::BUSW addr = a;`
399			`char *ptr = m_buf;`
400
401			`if (len <= 0)`
402			`return;`
403	11	dgisselq	`DBGPRINTF("READV(%08x,%d,#%4d)\n", a, inc, len);`
404	5	dgisselq
405			`ptr = encode_address(a);`
406			`try {`
407			`while(cmdrd < len) {`
408			`// ptr = m_buf;`
409			`do {`
410			`int nrd = len-cmdrd;`
411			`if (nrd > READBLOCK)`
412			`nrd = READBLOCK;`
413			`if (cmdrd-nread + nrd>READAHEAD+READBLOCK)`
414			`nrd = READAHEAD+READBLOCK-(cmdrd-nread);`
415			`ptr = readcmd(inc, nrd, ptr);`
416			`cmdrd += nrd;`
417			`} while((cmdrd-nread < READAHEAD+READBLOCK)&&(cmdrd< len));`
418
419			`ptr++ = '\n'; ptr = '\0';`
420			`m_dev->write(m_buf, (ptr-m_buf));`
421
422			`while(nread<(cmdrd-READAHEAD)) {`
423			`buf[nread++] = readword();`
424			`} ptr = m_buf;`
425			`} while(nread<len) {`
426			`buf[nread++] = readword();`
427			`}`
428			`} catch(BUSERR b) {`
429			`throw BUSERR(a+((inc)?nread:0));`
430			`}`
431
432			`if ((unsigned)m_lastaddr != (a+((inc)?(len):0))) {`
433	11	dgisselq	`DBGPRINTF("TTYBUS::READV(a=%08x,inc=%d,len=%4x,x) ERR: (Last) %08x != %08x + %08x (Expected)\n", a, inc, len, m_lastaddr, a, (inc)?(len):0);`
434	5	dgisselq	`printf("TTYBUS::READV(a=%08x,inc=%d,len=%4x,x) ERR: (Last) %08x != %08x + %08x (Expected)\n", a, inc, len, m_lastaddr, a, (inc)?(len):0);`
435			`sleep(1);`
436			`assert((int)m_lastaddr == (a+(inc)?(len):0));`
437			`exit(-3);`
438			`}`
439			`}`
440
441			`void TTYBUS::readi(const TTYBUS::BUSW a, const int len, TTYBUS::BUSW *buf) {`
442			`readv(a, 1, len, buf);`
443			`}`
444
445			`void TTYBUS::readz(const TTYBUS::BUSW a, const int len, TTYBUS::BUSW *buf) {`
446			`readv(a, 0, len, buf);`
447			`}`
448
449			`TTYBUS::BUSW TTYBUS::readword(void) {`
450			`TTYBUS::BUSW val = 0;`
451			`int nr;`
452			`unsigned sixbits;`
453
454	11	dgisselq	`DBGPRINTF("READ-WORD()\n");`
455	5	dgisselq
456			`bool found_start = false;`
457			`do {`
458			`// Blocking read (for now)`
459			`do {`
460			`nr = lclreadcode(&m_buf[0], 1);`
461			`} while (nr < 1);`
462
463			`sixbits = chardec(m_buf[0]);`
464
465			`if (sixbits&(~0x03f)) {`
466			`// Ignore new lines, unprintables, and characters`
467			`// not a part of our code`
468			`;`
469			`} else if (sixbits < 6) {`
470			`switch(sixbits) {`
471			`case 0: break; // Idle -- ignore`
472			`case 1: break; // Idle, but the bus is busy`
473			`case 2: break; // Write acknowledgement, ignore it here`
474			`case 3:`
475			`m_bus_err = true;`
476			`throw BUSERR(0);`
477			`break;`
478			`case 4:`
479			`m_interrupt_flag = true;`
480			`break;`
481			`case 5:`
482			`m_bus_err = true;`
483			`throw BUSERR(0);`
484			`break;`
485			`}`
486			`} else if (0x08 == (sixbits & 0x3c)) { // Set 32-bit address`
487			`do {`
488			`nr += lclreadcode(&m_buf[nr], 6-nr);`
489			`} while (nr < 6);`
490
491			`val = chardec(m_buf[0]) & 0x03;`
492			`val = (val<<6) \| (chardec(m_buf[1]) & 0x03f);`
493			`val = (val<<6) \| (chardec(m_buf[2]) & 0x03f);`
494			`val = (val<<6) \| (chardec(m_buf[3]) & 0x03f);`
495			`val = (val<<6) \| (chardec(m_buf[4]) & 0x03f);`
496			`val = (val<<6) \| (chardec(m_buf[5]) & 0x03f);`
497
498			`m_addr_set = true;`
499			`m_lastaddr = val;`
500
501	11	dgisselq	`DBGPRINTF("RCVD ADDR: 0x%08x\n", val);`
502	5	dgisselq	`} else if (0x0c == (sixbits & 0x03c)) { // Set 32-bit address,compressed`
503			`int nw = (sixbits & 0x03) + 2;`
504			`do {`
505			`nr += lclreadcode(&m_buf[nr], nw-nr);`
506			`} while (nr < nw);`
507
508			`if (nw == 2) {`
509			`val = chardec(m_buf[1]);`
510			`} else if (nw == 3) {`
511			`val = chardec(m_buf[1]);`
512			`val = (val<<6) \| (chardec(m_buf[2]) & 0x03f);`
513			`} else if (nw == 4) {`
514			`val = chardec(m_buf[1]);`
515			`val = (val<<6) \| (chardec(m_buf[2]) & 0x03f);`
516			`val = (val<<6) \| (chardec(m_buf[3]) & 0x03f);`
517			`} else { // if (nw == 5)`
518			`val = chardec(m_buf[1]);`
519			`val = (val<<6) \| (chardec(m_buf[2]) & 0x03f);`
520			`val = (val<<6) \| (chardec(m_buf[3]) & 0x03f);`
521			`val = (val<<6) \| (chardec(m_buf[4]) & 0x03f);`
522			`}`
523
524			`m_addr_set = true;`
525			`m_lastaddr = val;`
526	11	dgisselq	`DBGPRINTF("RCVD ADDR: 0x%08x (%d bytes)\n", val, nw+1);`
527	5	dgisselq	`} else`
528			`found_start = true;`
529			`} while(!found_start);`
530
531			`int rdaddr;`
532
533			`if (0x06 == (sixbits & 0x03e)) { // Tbl read, last value`
534			`rdaddr = (m_rdaddr-1)&0x03ff;`
535			`val = m_readtbl[rdaddr];`
536			`m_lastaddr += (sixbits&1);`
537			`} else if (0x10 == (sixbits & 0x030)) { // Tbl read, up to 521 into past`
538			`int idx;`
539			`do {`
540			`nr += lclreadcode(&m_buf[nr], 2-nr);`
541			`} while (nr < 2);`
542
543			`idx = (chardec(m_buf[0])>>1) & 0x07;`
544			`idx = ((idx<<6) \| (chardec(m_buf[1]) & 0x03f)) + 2 + 8;`
545			`rdaddr = (m_rdaddr-idx)&0x03ff;`
546			`val = m_readtbl[rdaddr];`
547			`m_lastaddr += (sixbits&1);`
548			`} else if (0x20 == (sixbits & 0x030)) { // Tbl read, 2-9 into past`
549			`rdaddr = (m_rdaddr - (((sixbits>>1)&0x07)+2)) & 0x03ff;`
550			`val = m_readtbl[rdaddr];`
551			`m_lastaddr += (sixbits&1);`
552			`} else if (0x38 == (sixbits & 0x038)) { // Raw read`
553			`do {`
554			`nr += lclreadcode(&m_buf[nr], 6-nr);`
555			`} while (nr < 6);`
556
557			`val = (chardec(m_buf[0])>>1) & 0x03;`
558			`val = (val<<6) \| (chardec(m_buf[1]) & 0x03f);`
559			`val = (val<<6) \| (chardec(m_buf[2]) & 0x03f);`
560			`val = (val<<6) \| (chardec(m_buf[3]) & 0x03f);`
561			`val = (val<<6) \| (chardec(m_buf[4]) & 0x03f);`
562			`val = (val<<6) \| (chardec(m_buf[5]) & 0x03f);`
563
564			`m_readtbl[m_rdaddr++] = val; m_rdaddr &= 0x03ff;`
565			`m_lastaddr += (sixbits&1);`
566			`}`
567
568			`return val;`
569			`}`
570
571			`void TTYBUS::usleep(unsigned ms) {`
572			`if (m_dev->poll(ms)) {`
573			`int nr;`
574			`nr = m_dev->read(m_buf, 16);`
575			`if (nr == 0) {`
576			`// Connection closed, let it drop`
577			`DBGPRINTF("Connection closed!!\n");`
578			`m_dev->close();`
579			`exit(-1);`
580			`} for(int i=0; i<nr; i++) {`
581			`if (m_buf[i] == TTYC_INT) {`
582			`m_interrupt_flag = true;`
583	11	dgisselq	`DBGPRINTF("!!!!!!!!!!!!!!!!! ----- INTERRUPT!\n");`
584	5	dgisselq	`} else if (m_buf[i] == TTYC_IDLE) {`
585	11	dgisselq	`DBGPRINTF("Interface is now idle\n");`
586	5	dgisselq	`} else if (m_buf[i] == TTYC_WRITE) {`
587			`} else if (m_buf[i] == TTYC_RESET) {`
588	11	dgisselq	`DBGPRINTF("Bus was RESET!\n");`
589	5	dgisselq	`} else if (m_buf[i] == TTYC_ERR) {`
590			`DBGPRINTF("Bus error\n");`
591			`} else if (m_buf[i] == TTYC_BUSY) {`
592	11	dgisselq	`DBGPRINTF("Interface is ... busy ??\n");`
593	5	dgisselq	`}`
594			`// else if (m_buf[nr] == 'Q')`
595			`// else if (m_buf[nr] == 'W')`
596			`// else if (m_buf[nr] == '\n')`
597			`}`
598			`}`
599			`}`
600
601			`void TTYBUS::wait(void) {`
602			`if (m_interrupt_flag)`
603			`DBGPRINTF("INTERRUPTED PRIOR TO WAIT()\n");`
604			`do {`
605			`usleep(200);`
606			`} while(!m_interrupt_flag);`
607			`}`
608
609			`// TTYBUS: 3503421 ~= 3.3 MB, stopwatch = 1:18.5 seconds, vs 53.8 secs`
610			`// If you issue two 512 word reads at once, time drops to 41.6 secs.`
611			`// PORTBUS: 6408320 ~= 6.1 MB, ... 26% improvement, 53 seconds real time`
612