ref: a71551021e10fc8b47f12176d6aacf90936c328c
dir: /emu/Nt/deveia.c/
/*
* Windows serial driver
*
* to do:
* scan the registry for serial ports?
*/
#define Unknown win_Unknown
#include <windows.h>
#undef Unknown
#undef Sleep
#include "dat.h"
#include "fns.h"
#include "error.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <lm.h>
#include <direct.h>
// local fcts
static void openport(int);
static void wrctl(int, char*);
static long rdstat(int, void*, long, ulong );
enum
{
Devchar = 't',
Ndataqid = 1,
Nctlqid,
Nstatqid,
Nqid = 3, /* number of QIDs */
Maxctl = 128,
// in/out buffer sizes for comm port (NT requires an even number)
// set it to x* the max styx message rounded up to the
// nearest 4 byte value
CommBufSize = ((((8192+128)*2)+3) & ~3)
};
/*
* Macros to manage QIDs
*/
#define NETTYPE(x) ((x)&0x0F)
#define NETID(x) ((x)>>4)
#define NETQID(i,t) (((i)<<4)|(t))
static Dirtab *eiadir;
static int ndir;
typedef struct Eia Eia;
struct Eia {
Ref r;
HANDLE comfh; //handle to open port
int restore; //flag to restore prev. states
DCB dcb; //win32 device control block used for restore
int id; //index to host port name in sysdev
};
// the same timeouts are used for all ports
// currently there is no Inferno interface to
// change the timeouts.
static COMMTIMEOUTS timeouts;
// std win32 serial port names are COM1..COM4
// however there can be more and they can be
// named anything. we should be more flexible
// pehaps adding a ctl command to allow you to
// access any win32 comm port
static char* sysdev[] = {
"COM1:",
"COM2:",
"COM3:",
"COM4:",
"COM5:",
"COM6:",
"COM7:",
"COM8:",
NULL
};
static Eia *eia;
typedef struct OptTable OptTable;
struct OptTable {
char *str;
DWORD flag;
};
#define BAD ((DWORD)-1)
// valid bit-per-byte sizes
static OptTable size[] = {
{"5", 5},
{"6", 6},
{"7", 7},
{"8", 8},
{NULL, BAD}
};
// valid stop bits
static OptTable stopbits[] = {
{"1", ONESTOPBIT},
{"1.5", ONE5STOPBITS},
{"2", TWOSTOPBITS},
{NULL, BAD}
};
// valid parity settings
static OptTable parity[] = {
{"o", ODDPARITY},
{"e", EVENPARITY},
{"s", SPACEPARITY},
{"m", MARKPARITY},
{"n", NOPARITY},
{NULL, NOPARITY}
};
static char *
ftos(OptTable *tbl, DWORD flag)
{
while(tbl->str && tbl->flag != flag)
tbl++;
if(tbl->str == 0)
return "unknown";
return tbl->str;
}
static DWORD
stof(OptTable *tbl, char *str)
{
while(tbl->str && strcmp(tbl->str, str) != 0)
tbl++;
return tbl->flag;
}
static void
eiainit(void)
{
int i,x;
byte ports; //bitmask of active host ports
int nports; //number of active host ports
int max; //number of highest port
Dirtab *dp;
// setup the timeouts; choose carefully
timeouts.ReadIntervalTimeout = 2;
timeouts.ReadTotalTimeoutMultiplier = 0;
timeouts.ReadTotalTimeoutConstant = 200;
timeouts.WriteTotalTimeoutMultiplier = 0;
timeouts.WriteTotalTimeoutConstant = 400;
// check to see which ports exist by trying to open them
// keep results in a bitmask
ports = nports = max = 0;
for(i=0; (sysdev[i] != NULL) && (i<8); i++) {
HANDLE comfh = CreateFile(sysdev[i], 0, 0, NULL, /* no security attrs */
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(comfh != INVALID_HANDLE_VALUE) {
ports |= 1<<i;
CloseHandle(comfh);
nports++;
max = i;
}
}
if(nports == 0)
return; //no ports
// allocate directory table and eia structure
// for each active port.
ndir = Nqid*nports+1;
dp = eiadir = malloc(ndir*sizeof(Dirtab));
if(dp == 0)
panic("eiainit");
eia = malloc(nports*sizeof(Eia));
if(eia == 0) {
free(dp);
panic("eiainit");
}
// fill in the directory table and initialize
// the eia structure. skip inactive ports.
sprint(dp->name, ".");
dp->qid.path = 0;
dp->qid.type = QTDIR;
dp->perm = DMDIR|0555;
dp++;
x = 0; // index in eia[]
for(i = 0; i <= max; i++) {
if( (ports & (1<<i)) == 0)
continue; //port 'i' is not active
sprint(dp->name, "eia%d", i);
dp->qid.path = NETQID(x, Ndataqid);
dp->perm = 0660;
dp++;
sprint(dp->name, "eia%dctl", i);
dp->qid.path = NETQID(x, Nctlqid);
dp->perm = 0660;
dp++;
sprint(dp->name, "eia%dstatus", i);
dp->qid.path = NETQID(x, Nstatqid);
dp->perm = 0660;
dp++;
// init the eia structure
eia[x].restore = 0;
eia[x].id = i;
x++;
}
}
static Chan*
eiaattach(char *spec)
{
if(eiadir == nil)
error(Enodev);
return devattach(Devchar, spec);
}
static Walkqid*
eiawalk(Chan *c, Chan *nc, char **name, int nname)
{
return devwalk(c, nc, name, nname, eiadir, ndir, devgen);
}
static int
eiastat(Chan *c, uchar *db, int n)
{
return devstat(c, db, n, eiadir, ndir, devgen);
}
static Chan*
eiaopen(Chan *c, int mode)
{
int port = NETID(c->qid.path);
c = devopen(c, mode, eiadir, ndir, devgen);
switch(NETTYPE(c->qid.path)) {
case Nctlqid:
case Ndataqid:
case Nstatqid:
if(incref(&eia[port].r) != 1)
break;
if(waserror()) {
decref(&eia[port].r);
nexterror();
}
openport(port);
poperror();
break;
}
return c;
}
static void
eiaclose(Chan *c)
{
int port = NETID(c->qid.path);
if((c->flag & COPEN) == 0)
return;
switch(NETTYPE(c->qid.path)) {
case Nctlqid:
case Ndataqid:
case Nstatqid:
if(decref(&eia[port].r) == 0) {
osenter();
CloseHandle(eia[port].comfh);
osleave();
}
break;
}
}
static long
eiaread(Chan *c, void *buf, long n, vlong offset)
{
DWORD cnt;
int port = NETID(c->qid.path);
BOOL good;
if(c->qid.type & QTDIR)
return devdirread(c, buf, n, eiadir, ndir, devgen);
switch(NETTYPE(c->qid.path)) {
case Ndataqid:
cnt = 0;
// if ReadFile timeouts and cnt==0 then just re-read
// this will give osleave() a chance to detect an
// interruption (i.e. killprog)
while(cnt==0) {
osenter();
good = ReadFile(eia[port].comfh, buf, n, &cnt, NULL);
SleepEx(0,FALSE); //allow another thread access to port
osleave();
if(!good)
oserror();
}
return cnt;
case Nctlqid:
return readnum(offset, buf, n, eia[port].id, NUMSIZE);
case Nstatqid:
return rdstat(port, buf, n, offset);
}
return 0;
}
static long
eiawrite(Chan *c, void *buf, long n, vlong offset)
{
DWORD cnt;
char cmd[Maxctl];
int port = NETID(c->qid.path);
BOOL good;
uchar *data;
if(c->qid.type & QTDIR)
error(Eperm);
switch(NETTYPE(c->qid.path)) {
case Ndataqid:
cnt = 0;
data = (uchar*)buf;
// if WriteFile times out (i.e. return true; cnt<n) then
// allow osleave() to check for an interrupt otherwise try
// to send the unsent data.
while(n>0) {
osenter();
good = WriteFile(eia[port].comfh, data, n, &cnt, NULL);
osleave();
if(!good)
oserror();
data += cnt;
n -= cnt;
}
return (data-(uchar*)buf);
case Nctlqid:
if(n >= sizeof(cmd))
n = sizeof(cmd)-1;
memmove(cmd, buf, n);
cmd[n] = 0;
wrctl(port, cmd);
return n;
}
return 0;
}
static int
eiawstat(Chan *c, uchar *dp, int n)
{
Dir d;
int i;
if(!iseve())
error(Eperm);
if(c->qid.type & QTDIR)
error(Eperm);
if(NETTYPE(c->qid.path) == Nstatqid)
error(Eperm);
n = convM2D(dp, n, &d, nil);
i = Nqid*NETID(c->qid.path)+NETTYPE(c->qid.path)-Ndataqid;
if(d.mode != ~0UL)
eiadir[i+1].perm = d.mode&0666;
return n;
}
Dev eiadevtab = {
Devchar,
"eia",
eiainit,
eiaattach,
eiawalk,
eiastat,
eiaopen,
devcreate,
eiaclose,
eiaread,
devbread,
eiawrite,
devbwrite,
devremove,
eiawstat
};
//
// local functions
//
/*
* open the indicated comm port and then set
* the default settings for the port.
*/
static void
openport(int port)
{
Eia* p = &eia[port];
// open the port
p->comfh = CreateFile(sysdev[p->id],
GENERIC_READ|GENERIC_WRITE, //open underlying port for rd/wr
0, //comm port can't be shared
NULL, //no security attrs
OPEN_EXISTING, //a must for comm port
FILE_ATTRIBUTE_NORMAL, //nonoverlapped io
NULL); //another must for comm port
if(p->comfh == INVALID_HANDLE_VALUE)
oserror();
if(waserror()){
CloseHandle(p->comfh);
p->comfh = INVALID_HANDLE_VALUE;
nexterror();
}
// setup in/out buffers (NT requires an even number)
if(!SetupComm(p->comfh, CommBufSize, CommBufSize))
oserror();
// either use existing settings or set defaults
if(!p->restore) {
// set default settings
if(!GetCommState(p->comfh, &p->dcb))
oserror();
p->dcb.BaudRate = 9600;
p->dcb.ByteSize = 8;
p->dcb.fParity = 0;
p->dcb.Parity = NOPARITY;
p->dcb.StopBits = ONESTOPBIT;
p->dcb.fInX = 0; //default to xoff
p->dcb.fOutX = 0;
p->dcb.fAbortOnError = 1; //read/write abort on err
}
// set state and timeouts
if(!SetCommState(p->comfh, &p->dcb) ||
!SetCommTimeouts(p->comfh, &timeouts))
oserror();
poperror();
}
/*
* Obtain status information on the com port.
*/
static long
rdstat(int port, void *buf, long n, ulong offset)
{
HANDLE comfh = eia[port].comfh;
char str[Maxctl];
char *s;
DCB dcb;
DWORD modemstatus;
DWORD porterr;
COMSTAT portstat;
int frame, overrun, i;
// valid line control ids
static enum {
L_CTS, L_DSR, L_RING, L_DCD, L_DTR, L_RTS, L_MAX
};
int status[L_MAX];
// line control strings (should match above id's)
static char* lines[] = {
"cts", "dsr", "ring", "dcd", "dtr", "rts", NULL
};
// get any error conditions; also clears error flag
// and enables io
if(!ClearCommError(comfh, &porterr, &portstat))
oserror();
// get comm port state
if(!GetCommState(comfh, &dcb))
oserror();
// get modem line information
if(!GetCommModemStatus(comfh, &modemstatus))
oserror();
// now set our local flags
status[L_CTS] = MS_CTS_ON & modemstatus;
status[L_DSR] = MS_DSR_ON & modemstatus;
status[L_RING] = MS_RING_ON & modemstatus;
status[L_DCD] = MS_RLSD_ON & modemstatus;
status[L_DTR] = FALSE; //?? cand this work: dcb.fDtrControl;
status[L_RTS] = FALSE; //?? dcb.fRtsControl;
frame = porterr & CE_FRAME;
overrun = porterr & CE_OVERRUN;
/* TO DO: mimic native eia driver's first line */
s = seprint(str, str+sizeof(str), "opens %d ferr %d oerr %d baud %d",
eia[port].r.ref-1,
frame,
overrun,
dcb.BaudRate);
// add line settings
for(i=0; i < L_MAX; i++)
if(status[i])
s = seprint(s, str+sizeof(str), " %s", lines[i]);
seprint(s, str+sizeof(str), "\n");
return readstr(offset, buf, n, str);
}
//
// write on ctl file. modify the settings for
// the underlying port.
//
static void
wrctl(int port, char *cmd)
{
DCB dcb;
int nf, n, i;
char *f[16];
HANDLE comfh = eia[port].comfh;
DWORD flag, opt;
BOOL rslt;
int chg;
// get the current settings for the port
if(!GetCommState(comfh, &dcb))
oserror();
chg = 0;
nf = tokenize(cmd, f, nelem(f));
for(i = 0; i < nf; i++){
if(strcmp(f[i], "break") == 0){
if(!SetCommBreak(comfh))
oserror();
SleepEx((DWORD)300, FALSE);
if(!ClearCommBreak(comfh))
oserror();
continue;
}
n = atoi(f[i]+1);
switch(*f[i]) {
case 'B':
case 'b': // set the baud rate
if(n < 110)
error(Ebadarg);
dcb.BaudRate = n;
chg = 1;
break;
case 'C':
case 'c':
/* dcd */
break;
case 'D':
case 'd': // set DTR
opt = n ? SETDTR : CLRDTR;
if(!EscapeCommFunction(comfh, opt))
oserror();
break;
case 'E':
case 'e':
/* dsr */
break;
case 'F':
case 'f': // flush any untransmitted data
if(!PurgeComm(comfh, PURGE_TXCLEAR))
oserror();
break;
case 'H':
case 'h':
/* hangup */
/* TO DO: close handle */
break;
case 'I':
case 'i':
/* fifo: nothing to do */
break;
case 'K':
case 'k':
/* send a break */
if(!SetCommBreak(comfh))
oserror();
SleepEx((DWORD)300, FALSE);
if(!ClearCommBreak(comfh))
oserror();
break;
case 'L':
case 'l': // set bits per byte
flag = stof(size, f[0]+1);
if(flag == BAD)
error(Ebadarg);
dcb.ByteSize = (BYTE)flag;
chg = 1;
break;
case 'M':
case 'm': // set CTS (modem control)
dcb.fOutxCtsFlow = (n!=0);
chg = 1;
break;
case 'N':
case 'n':
/* don't block on output */
break;
case 'P':
case 'p': // set parity -- even or odd
flag = stof(parity, f[0]+1);
if(flag==BAD)
error(Ebadarg);
dcb.Parity = (BYTE)flag;
chg = 1;
break;
case 'Q':
case 'q':
/* set i/o queue limits */
break;
case 'R':
case 'r': // set RTS
opt = n ? SETRTS : CLRRTS;
if(!EscapeCommFunction(comfh, opt))
oserror();
break;
case 'S':
case 's': // set stop bits -- valid: 1 or 2 (win32 allows 1.5??)
flag = stof(stopbits, f[0]+1);
if(flag==BAD)
error(Ebadarg);
dcb.StopBits = flag;
chg = 1;
break;
case 'T':
case 't':
break;
case 'W':
case 'w':
/* set uart timer */
break;
case 'X':
case 'x': // xon/xoff
opt = n ? SETXON : SETXOFF;
if(!EscapeCommFunction(comfh, opt))
oserror();
break;
default:
/* ignore */
break;
}
}
if(!chg)
return;
// make the changes on the underlying port, but flush
// outgoing chars down the port before
osenter();
rslt = FlushFileBuffers(comfh);
if(rslt)
rslt = SetCommState(comfh, &dcb);
osleave();
if(!rslt)
oserror();
eia[port].restore = 1;
eia[port].dcb = dcb;
}