## diffname gnot/devcons.c 1990/03091
## diff -e /dev/null /n/bootesdump/1990/03091/sys/src/9/68020/devcons.c
0a
#include "u.h"
#include "lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "io.h"
#include "errno.h"
#include "devtab.h"
static struct
{
Lock;
int printing;
int c;
}printq;
typedef struct IOQ IOQ;
#define NQ 4096
struct IOQ{
union{
Lock;
QLock;
};
uchar buf[NQ];
uchar *in;
uchar *out;
int state;
Rendez r;
};
IOQ kbdq; /* qlock to getc; interrupt putc's */
IOQ lineq; /* lock to getc; interrupt putc's */
void
printinit(void)
{
lock(&printq); /* allocate lock */
unlock(&printq);
kbdq.in = kbdq.buf;
kbdq.out = kbdq.buf;
lineq.in = lineq.buf;
lineq.out = lineq.buf;
qlock(&kbdq); /* allocate qlock */
qunlock(&kbdq);
lock(&lineq); /* allocate lock */
unlock(&lineq);
screeninit();
}
/*
* Print a string on the console.
*/
void
putstrn(char *str, long n)
{
int s;
s = splhi();
lock(&printq);
printq.printing = 1;
while(--n >= 0)
screenputc(*str++);
printq.printing = 0;
unlock(&printq);
splx(s);
}
int
cangetc(IOQ *q)
{
return q->in != q->out;
}
int
isbrkc(IOQ *q)
{
uchar *p;
for(p=q->out; p!=q->in; ){
if(*p==0x04 || *p=='\n')
return 1;
p++;
if(p >= q->buf+sizeof(q->buf))
p = q->buf;
}
return 0;
}
int
getc(IOQ *q)
{
int c;
if(q->in == q->out)
return -1;
c = *q->out++;
if(q->out == q->buf+sizeof(q->buf))
q->out = q->buf;
return c;
}
int
sprint(char *s, char *fmt, ...)
{
return donprint(s, s+PRINTSIZE, fmt, (&fmt+1)) - s;
}
int
print(char *fmt, ...)
{
char buf[PRINTSIZE];
int n;
n = donprint(buf, buf+sizeof(buf), fmt, (&fmt+1)) - buf;
putstrn(buf, n);
return n;
}
void
panic(char *fmt, ...)
{
char buf[PRINTSIZE];
int n;
strcpy(buf, "panic: ");
n = donprint(buf+7, buf+sizeof(buf), fmt, (&fmt+1)) - buf;
buf[n] = '\n';
putstrn(buf, n+1);
exit();
}
int
pprint(char *fmt, ...)
{
char buf[2*PRINTSIZE];
Chan *c;
int n;
c = u->fd[2];
if(c==0 || (c->mode!=OWRITE && c->mode!=ORDWR))
return;
n = sprint(buf, "%s %d: ", u->p->text, u->p->pid);
n = donprint(buf+n, buf+sizeof(buf), fmt, (&fmt+1)) - buf;
qlock(c);
if(waserror()){
qunlock(c);
return;
}
(*devtab[c->type].write)(c, buf, n);
c->offset += n;
qunlock(c);
return n;
}
void
prflush(void)
{
while(printq.printing)
delay(100);
}
void
echo(int c)
{
char ch;
/*
* ^t hack BUG
*/
if(c == 0x14)
DEBUG();
if(c == 0x15)
putstrn("^U\n", 3);
else{
ch = c;
putstrn(&ch, 1);
}
}
/*
* Put character into read queue at interrupt time.
* Always called splhi from proc 0.
*/
void
kbdchar(int c)
{
if(c == '\r')
c = '\n';
echo(c);
*kbdq.in++ = c;
if(kbdq.in == kbdq.buf+sizeof(kbdq.buf))
kbdq.in = kbdq.buf;
if(c=='\n' || c==0x04)
wakeup(&kbdq.r);
}
int
consactive(void)
{
return printq.printing;
}
/*
* I/O interface
*/
enum{
Qdir,
Qcons,
Qcputime,
Qnull,
Qpgrpid,
Qpid,
Qppid,
Qtime,
Quser,
};
Dirtab consdir[]={
"cons", Qcons, 0, 0600,
"cputime", Qcputime, 72, 0600,
"null", Qnull, 0, 0600,
"pgrpid", Qpgrpid, 12, 0600,
"pid", Qpid, 12, 0600,
"ppid", Qppid, 12, 0600,
"time", Qtime, 12, 0600,
"user", Quser, 0, 0600,
};
#define NCONS (sizeof consdir/sizeof(Dirtab))
ulong boottime; /* seconds since epoch at boot */
long
seconds(void)
{
return boottime + MACHP(0)->ticks*MS2HZ/1000;
}
int
readnum(ulong off, char *buf, ulong n, ulong val, int size)
{
char tmp[64];
Op op = (Op){ tmp, tmp+sizeof(tmp), &val, size-1, 0, FUNSIGN|FLONG };
numbconv(&op, 10);
tmp[size-1] = ' ';
off %= size;
if(off+n > size)
n = size-off;
memcpy(buf, tmp+off, n);
return n;
}
int
readstr(ulong off, char *buf, ulong n, char *str)
{
int size;
size = strlen(str);
off %= size;
if(off+n > size)
n = size-off;
memcpy(buf, str+off, n);
return n;
}
void
consreset(void)
{
}
void
consinit(void)
{
}
Chan*
consattach(char *spec)
{
return devattach('c', spec);
}
Chan*
consclone(Chan *c, Chan *nc)
{
return devclone(c, nc);
}
int
conswalk(Chan *c, char *name)
{
return devwalk(c, name, consdir, NCONS, devgen);
}
void
consstat(Chan *c, char *dp)
{
devstat(c, dp, consdir, NCONS, devgen);
}
Chan*
consopen(Chan *c, int omode)
{
if(c->qid==Quser && omode==(OWRITE|OTRUNC)){
/* truncate? */
if(strcmp(u->p->pgrp->user, "bootes") == 0) /* BUG */
u->p->pgrp->user[0] = 0;
else
error(0, Eperm);
}
return devopen(c, omode, consdir, NCONS, devgen);
}
void
conscreate(Chan *c, char *name, int omode, ulong perm)
{
error(0, Eperm);
}
void
consclose(Chan *c)
{
}
long
consread(Chan *c, void *buf, long n)
{
int ch, i, j, k;
ulong l;
uchar *out;
char *cbuf = buf;
char *user;
int userlen;
char tmp[6*NUMSIZE];
if(n <= 0)
return n;
switch(c->qid&~CHDIR){
case Qdir:
return devdirread(c, buf, n, consdir, NCONS, devgen);
case Qcons:
qlock(&kbdq);
while(!cangetc(&lineq)){
sleep(&kbdq.r, (int(*)(void*))isbrkc, &kbdq);
do{
ch = getc(&kbdq);
switch(ch){
case '\b':
if(lineq.in != lineq.out){
if(lineq.in == lineq.buf)
lineq.in = lineq.buf+sizeof(lineq.buf);
lineq.in--;
}
break;
case 0x15:
lineq.in = lineq.out;
break;
default:
*lineq.in++ = ch;
if(lineq.in == lineq.buf+sizeof(lineq.buf))
lineq.in = lineq.buf;
}
}while(ch!='\n' && ch!=0x04);
}
i = 0;
while(n>0){
ch = getc(&lineq);
if(ch == 0x04 || ch == -1)
break;
i++;
*cbuf++ = ch;
--n;
}
qunlock(&kbdq);
return i;
case Qcputime:
k = c->offset % sizeof tmp;
if(k+n > sizeof tmp)
n = sizeof tmp - k;
/* easiest to format in a separate buffer and copy out */
for(i=0; i<6 && NUMSIZE*i<k+n; i++){
l = u->p->time[i];
if(i == TReal)
l = MACHP(0)->ticks - l;
l *= MS2HZ;
readnum(0, tmp+NUMSIZE*i, NUMSIZE, l, NUMSIZE);
}
memcpy(buf, tmp+k, n);
return n;
case Qpgrpid:
return readnum(c->offset, buf, n, u->p->pgrp->pgrpid, NUMSIZE);
case Qpid:
return readnum(c->offset, buf, n, u->p->pid, NUMSIZE);
case Qppid:
return readnum(c->offset, buf, n, u->p->parentpid, NUMSIZE);
case Qtime:
return readnum(c->offset, buf, n, boottime+MACHP(0)->ticks/(1000/MS2HZ), 12);
case Quser:
return readstr(c->offset, buf, n, u->p->pgrp->user);
case Qnull:
return 0;
default:
panic("consread %lux\n", c->qid);
return 0;
}
}
long
conswrite(Chan *c, void *va, long n)
{
char cbuf[64];
char buf[256];
long l, m;
char *a = va;
switch(c->qid){
case Qcons:
/*
* Damn. Can't page fault in putstrn, so copy the data locally.
*/
l = n;
while(l > 0){
m = l;
if(m > sizeof buf)
m = sizeof buf;
memcpy(buf, a, m);
putstrn(a, m);
a += m;
l -= m;
}
break;
case Qtime:
if(n<=0 || boottime!=0) /* only one write please */
return 0;
if(n >= sizeof cbuf)
n = sizeof cbuf - 1;
memcpy(cbuf, a, n);
cbuf[n-1] = 0;
boottime = strtoul(a, 0, 0);
break;
case Quser:
if(u->p->pgrp->user[0]) /* trying to overwrite /dev/user */
error(0, Eperm);
if(c->offset >= NAMELEN-1)
return 0;
if(c->offset+n >= NAMELEN-1)
n = NAMELEN-1 - c->offset;
memcpy(u->p->pgrp->user+c->offset, a, n);
u->p->pgrp->user[c->offset+n] = 0;
break;
case Qcputime:
case Qpgrpid:
case Qpid:
case Qppid:
error(0, Eperm);
case Qnull:
break;
default:
error(0, Egreg);
}
return n;
}
void
consremove(Chan *c)
{
error(0, Eperm);
}
void
conswstat(Chan *c, char *dp)
{
error(0, Eperm);
}
void
conserrstr(Error *e, char *buf)
{
rooterrstr(e, buf);
}
void
consuserstr(Error *e, char *buf)
{
strcpy(buf, u->p->pgrp->user);
}
typedef struct Incon{
unsigned char cdata; unsigned char u0;
unsigned char cstatus; unsigned char u1;
unsigned char creset; unsigned char u2;
unsigned char csend; unsigned char u3;
unsigned short data_cntl; /* data is high byte, cntl is low byte */
unsigned char status; unsigned char u5;
unsigned char reset; unsigned char u6;
unsigned char send; unsigned char u7;
}Incon;
inconintr(Ureg *ur)
{
int x;
x = ((Incon*)0x40700000)->status;
}
.
## diffname gnot/devcons.c 1990/0312
## diff -e /n/bootesdump/1990/03091/sys/src/9/68020/devcons.c /n/bootesdump/1990/0312/sys/src/9/68020/devcons.c
520a
*/
.
515a
/*
.
383c
k = c->offset;
if(k >= sizeof tmp)
return 0;
.
264c
if(off >= size)
return 0;
.
251c
if(off >= size)
return 0;
.
## diffname gnot/devcons.c 1990/0321
## diff -e /n/bootesdump/1990/0312/sys/src/9/68020/devcons.c /n/bootesdump/1990/0321/sys/src/9/68020/devcons.c
198a
}
void
kbdrepeat(int rep)
{
if(rep)
kbdq.repeat = 1;
else
kbdq.repeat = 0;
}
void
kbdclock(void)
{
if(kbdq.repeat==2 && (++kbdq.count&1))
kbdchar(kbdq.c);
.
190a
if(kbdq.repeat == 1){
kbdq.c = c;
kbdq.count = 0;
kbdq.repeat = 2;
}
.
187a
.
155a
poperror();
.
151c
return 0;
.
145c
return 0;
.
35a
struct{
IOQ; /* qlock to getc; interrupt putc's */
int c;
int repeat;
int count;
}kbdq;
.
33d
## diffname gnot/devcons.c 1990/0515
## diff -e /n/bootesdump/1990/0321/sys/src/9/68020/devcons.c /n/bootesdump/1990/0515/sys/src/9/68020/devcons.c
463a
case Qrcons:
.
404c
if(ch==-1 || (raw.ref==0 && ch==0x04))
.
402c
while(n > 0){
.
399c
unlock(&lineq);
}while(raw.ref==0 && ch!='\n' && ch!=0x04);
.
397c
lineq.in = lineq.buf;
.
393a
Default:
.
382a
if(raw.ref){
unlock(&lineq);
goto Default;
}
.
381a
lock(&lineq);
.
376a
case Qrcons:
.
357a
if(c->qid == Qrcons)
decref(&raw);
.
345a
if(c->qid == Qrcons)
if(incref(&raw) == 0){
lock(&lineq);
while((ch=getc(&kbdq)) != -1){
*lineq.in++ = ch;
if(lineq.in == lineq.buf+sizeof(lineq.buf))
lineq.in = lineq.buf;
}
unlock(&lineq);
}
.
338a
int ch;
.
257a
"rcons", Qrcons, 0, 0600,
.
246a
Qrcons,
.
210c
if(raw.ref || c=='\n' || c==0x04)
.
182a
if(raw.ref)
return;
.
90a
if(raw.ref)
return 1;
.
41a
Ref raw; /* whether kbd i/o is raw (rcons is open) */
.
33c
IOQ lineq;
.
## diffname gnot/devcons.c 1990/06111
## diff -e /n/bootesdump/1990/0515/sys/src/9/68020/devcons.c /n/bootesdump/1990/06111/sys/src/9/68020/devcons.c
470c
return readnum(c->offset, buf, n, boottime+TK2SEC(MACHP(0)->ticks), 12);
.
454c
l = TK2MS(l);
.
277c
return boottime + TK2SEC(MACHP(0)->ticks);
.
157c
n = doprint(buf+n, buf+sizeof(buf), fmt, (&fmt+1)) - buf;
.
141c
n = doprint(buf+7, buf+sizeof(buf), fmt, (&fmt+1)) - buf;
.
129c
n = doprint(buf, buf+sizeof(buf), fmt, (&fmt+1)) - buf;
.
120c
return doprint(s, s+PRINTSIZE, fmt, (&fmt+1)) - s;
.
## diffname gnot/devcons.c 1990/0617
## diff -e /n/bootesdump/1990/06111/sys/src/9/68020/devcons.c /n/bootesdump/1990/0617/sys/src/9/68020/devcons.c
401a
if(waserror()){
qunlock(&kbdq);
nexterror();
}
.
190a
if(c == 0x16)
dumpqueues();
.
## diffname gnot/devcons.c 1990/0619
## diff -e /n/bootesdump/1990/0617/sys/src/9/68020/devcons.c /n/bootesdump/1990/0619/sys/src/9/68020/devcons.c
380c
if(c->qid==Qrcons && (c->flag&COPEN))
.
## diffname gnot/devcons.c 1990/0629
## diff -e /n/bootesdump/1990/0619/sys/src/9/68020/devcons.c /n/bootesdump/1990/0629/sys/src/9/68020/devcons.c
574,592d
515a
case Qrs232:
qlock(&rs232oq);
l = n;
while(--l >= 0)
putc(&rs232oq, *a++);
splhi();
if(rs232oq.state == 0){
rs232oq.state = 1;
duartstartrs232o();
}
spllo();
qunlock(&rs232oq);
break;
.
448a
case Qrs232:
qlock(&rs232iq);
if(waserror()){
qunlock(&rs232iq);
nexterror();
}
while(!cangetc(&rs232iq))
sleep(&rs232iq.r, (int(*)(void*))cangetc, &rs232iq);
for(i=0; i<n; i++){
if((ch=getc(&rs232iq)) == -1)
break;
*cbuf++ = ch;
}
qunlock(&rs232iq);
return i;
.
359c
if(incref(&raw) == 1){
.
267a
"rs232", Qrs232, 0, 0600,
.
255a
Qrs232,
.
238a
getrs232o(void)
{
int c;
c = getc(&rs232oq);
if(c == -1)
rs232oq.state = 0;
return c;
}
int
.
237a
void
rs232ichar(int c)
{
*rs232iq.in++ = c;
if(rs232iq.in == rs232iq.buf+sizeof(rs232iq.buf))
rs232iq.in = rs232iq.buf;
wakeup(&rs232iq.r);
}
.
191,192d
186a
if(c == 0x16){
incontoggle();
urpdump();
dumpqueues();
}
.
116a
void
putc(IOQ *q, int c)
{
*q->in++ = c;
if(q->in == q->buf+sizeof(q->buf))
q->in = q->buf;
}
.
58a
lock(&rs232iq); /* allocate lock */
unlock(&rs232iq);
lock(&rs232oq); /* allocate lock */
unlock(&rs232oq);
.
52a
rs232iq.in = rs232iq.buf;
rs232iq.out = rs232iq.buf;
rs232oq.in = rs232oq.buf;
rs232oq.out = rs232oq.buf;
.
33a
IOQ rs232iq;
IOQ rs232oq;
.
20c
#define NQ 1024
.
## diffname gnot/devcons.c 1990/0702
## diff -e /n/bootesdump/1990/0629/sys/src/9/68020/devcons.c /n/bootesdump/1990/0702/sys/src/9/68020/devcons.c
206,207d
## diffname gnot/devcons.c 1990/0707
## diff -e /n/bootesdump/1990/0702/sys/src/9/68020/devcons.c /n/bootesdump/1990/0707/sys/src/9/68020/devcons.c
583d
576,581c
while(--l >= 0) {
while (putc(&rs232oq, *a) < 0)
sleep(&rs232oq.r, (int(*)(void*))canputc, &rs232oq);
a++;
if(rs232oq.state == 0){
splhi();
if(rs232oq.state == 0){
rs232oq.state = 1;
duartstartrs232o();
}
spllo();
}
.
540a
case Qklog:
qlock(&klogq);
if(waserror()){
qunlock(&klogq);
nexterror();
}
while(!cangetc(&klogq))
sleep(&klogq.r, (int(*)(void*))cangetc, &klogq);
for(i=0; i<n; i++){
if((ch=getc(&klogq)) == -1)
break;
*cbuf++ = ch;
}
qunlock(&klogq);
return i;
.
440c
return devdirread(c, buf, n, consdir, NCONS, consgen);
.
409c
return devopen(c, omode, consdir, NCONS, consgen);
.
384c
devstat(c, dp, consdir, NCONS, consgen);
.
378c
return devwalk(c, name, consdir, NCONS, consgen);
.
314a
static int
consgen(Chan *c, Dirtab *tab, int ntab, int i, Dir *dp)
{
if(tab==0 || i>=ntab)
return -1;
tab += i;
devdir(c, tab->qid, tab->name, tab->length, tab->perm, dp);
switch(dp->qid){
case Qrs232:
dp->length = cangetc(&rs232iq); break;
}
return 1;
}
.
310a
"klog", Qklog, 0, 0400,
.
297a
Qklog,
.
273a
wakeup(&rs232oq.r);
.
260,262c
putc(&rs232iq, c);
.
207c
if(c == 0x18)
mntdump();
.
205c
if(c == 0x16)
.
151a
int
kprint(char *fmt, ...)
{
char buf[PRINTSIZE];
int n;
n = doprint(buf, buf+sizeof(buf), fmt, (&fmt+1)) - buf;
putstrk(buf, n);
return n;
}
.
134a
void
putstrk(char *str, long n)
{
int s;
s = splhi();
lock(&klogq.put);
while(--n >= 0){
*klogq.in++ = *str++;
if(klogq.in == klogq.buf+sizeof(klogq.buf))
klogq.in = klogq.buf;
}
unlock(&klogq.put);
splx(s);
wakeup(&klogq.r);
}
.
130,132c
uchar *nextin;
if(q->in >= &q->buf[sizeof(q->buf)-1])
nextin = q->buf;
else
nextin = q->in+1;
if(nextin == q->out)
return -1;
*q->in = c;
q->in = nextin;
return 0;
.
127c
int
.
97a
canputc(IOQ *q)
{
return sizeof(q->buf)-cangetc(q)-1;
}
int
.
94c
int n = q->in - q->out;
if (n < 0)
n += sizeof(q->buf);
return n;
.
68a
lock(&klogq); /* allocate lock */
unlock(&klogq);
lock(&klogq.put); /* allocate lock */
unlock(&klogq.put);
.
58a
klogq.in = klogq.buf;
klogq.out = klogq.buf;
.
37a
IOQ;
Lock put;
}klogq;
struct{
.
## diffname gnot/devcons.c 1990/0808
## diff -e /n/bootesdump/1990/0707/sys/src/9/68020/devcons.c /n/bootesdump/1990/0808/sys/src/9/68020/devcons.c
675a
qunlock(&rs232oq);
break;
case Qrs232ctl:
qlock(&rs232oq);
if(waserror()){
qunlock(&rs232oq);
nexterror();
}
if(n>2 && n<sizeof buf && *a=='B'){
strncpy(buf, a, n);
buf[n] = 0;
duartbaud(strtoul(buf+1, 0, 0));
}else
error(0, Ebadarg);
.
576a
case Qrs232ctl:
return 0;
.
364a
"rs232ctl", Qrs232ctl, 0, 0600,
.
350a
Qrs232ctl,
.
## diffname gnot/devcons.c 1990/08101
## diff -e /n/bootesdump/1990/0808/sys/src/9/68020/devcons.c /n/bootesdump/1990/08101/sys/src/9/68020/devcons.c
680a
poperror();
.
670c
sleep(&rs232oq.r, canputc, &rs232oq);
.
666a
if(waserror()){
qunlock(&rs232oq);
nexterror();
}
.
629a
poperror();
.
624c
sleep(&klogq.r, cangetc, &klogq);
.
610a
case Qmsec:
return readnum(c->offset, buf, n, TK2MS(MACHP(0)->ticks), NUMSIZE);
case Qclock:
k = c->offset;
if(k >= 2*NUMSIZE)
return 0;
if(k+n > 2*NUMSIZE)
n = 2*NUMSIZE - k;
readnum(0, tmp, NUMSIZE, MACHP(0)->ticks, NUMSIZE);
readnum(0, tmp+NUMSIZE, NUMSIZE, HZ, NUMSIZE);
memcpy(buf, tmp+k, n);
return n;
.
609c
return readnum(c->offset, buf, n, boottime+TK2SEC(MACHP(0)->ticks), NUMSIZE);
.
575a
poperror();
.
570c
sleep(&rs232iq.r, cangetc, &rs232iq);
.
523c
sleep(&kbdq.r, isbrkc, &kbdq);
.
358,369c
"cons", Qcons, 0, 0600,
"cputime", Qcputime, 6*NUMSIZE, 0600,
"null", Qnull, 0, 0600,
"pgrpid", Qpgrpid, NUMSIZE, 0600,
"pid", Qpid, NUMSIZE, 0600,
"ppid", Qppid, NUMSIZE, 0600,
"rcons", Qrcons, 0, 0600,
"rs232", Qrs232, 0, 0600,
"rs232ctl", Qrs232ctl, 0, 0600,
"time", Qtime, NUMSIZE, 0600,
"user", Quser, 0, 0600,
"klog", Qklog, 0, 0400,
"msec", Qmsec, NUMSIZE, 0400,
"clock", Qclock, 2*NUMSIZE, 0400,
.
354a
Qmsec,
Qclock,
.
119a
IOQ *q = (IOQ *)arg;
.
118c
isbrkc(void *arg)
.
113a
IOQ *q = (IOQ *)arg;
.
112c
canputc(void *arg)
.
104a
IOQ *q = (IOQ *)arg;
.
103c
cangetc(void *arg)
.
20c
#define NQ 2048
.
## diffname gnot/devcons.c 1990/0825
## diff -e /n/bootesdump/1990/08101/sys/src/9/68020/devcons.c /n/bootesdump/1990/0825/sys/src/9/68020/devcons.c
290,291d
## diffname gnot/devcons.c 1990/0830
## diff -e /n/bootesdump/1990/0825/sys/src/9/68020/devcons.c /n/bootesdump/1990/0830/sys/src/9/68020/devcons.c
720a
strncpy(buf, a, n);
buf[n] = 0;
l = strtoul(buf+1, 0, 0);
switch(buf[0]){
case 'B':
duartbaud(l); break;
case 'D':
duartdtr(l); break;
case 'K':
duartbreak(l); break;
default:
error(0, Ebadarg);
}
.
715,719c
if(n<=2 || n>=sizeof buf)
.
586c
if(c->offset)
return 0;
*(char *)buf = duartinputport();
return 1;
.
## diffname gnot/devcons.c 1990/0831
## diff -e /n/bootesdump/1990/0830/sys/src/9/68020/devcons.c /n/bootesdump/1990/0831/sys/src/9/68020/devcons.c
792a
}
/*
* rs232 stream routines
*/
static void
rs232output(Rs232 *r)
{
int next;
Queue *q;
Block *bp;
qlock(&r->outlock);
q = r->wq;
/*
* free emptied blocks
*/
for(; r->out.f != r->out.r; r->out.f = NEXT(r->out.f)){
freeb(r->out.bp[r->out.f]);
r->out.bp[r->out.f] = 0;
}
/*
* stage new blocks
*/
bp = getq(q);
for(next = NEXT(r->out.w); bp && next!=r->out.r; next = NEXT(next)){
r->out.bp[r->out.w] = bp;
bp = getq(q);
r->out.w = next;
}
/*
* start output
*/
if(r->txenabled == 0){
r->txenabled = 1;
duartstartrs232o();
}
qunlock(&r->outlock);
}
static void
rs232input(Rs232 *r)
{
Queue *q;
char c;
Block *bp;
q = RD(r->wq);
bp = 0;
while((c = getc(&r->in)) >= 0){
if(bp == 0){
bp->flags |= S_DELIM;
bp = allocb(64);
}
*bp->wptr++ = c;
if(bp->wptr == bp->lim){
if(QFULL(q->next))
freeb(bp);
else
PUTNEXT(q, bp);
bp = 0;
}
}
if(bp){
if(QFULL(q->next))
freeb(bp);
else
PUTNEXT(q, bp);
}
}
static int
rs232stuff(void *arg)
{
Rs232 *r;
r = arg;
return (r->in.in != r->in.out) || (r->out.r != r->out.w)
|| (r->out.f != r->out.r);
}
static void
rs232kproc(void *a)
{
Rs232 *r;
r = a;
for(;;){
qlock(r);
if(r->wq != 0){
rs232output(r);
rs232input(r);
}
qunlock(r);
sleep(&r->r, rs232stuff, r);
}
}
static void
rs232open(Queue *q, Stream *c)
{
Rs232 *r;
r = &rs232;
RD(q)->ptr = r;
WR(q)->ptr = r;
r->wq = WR(q);
if(r->kstarted == 0){
r->in.in = r->in.out = r->in.buf;
kproc("rs232", rs232kproc, r);
r->kstarted = 1;
}
}
static void
rs232close(Queue *q)
{
Rs232 *r;
r = q->ptr;
qlock(r);
r->wq = 0;
qunlock(r);
}
static void
rs232oput(Queue *q, Block *bp)
{
if(bp->rptr == bp->wptr)
freeb(bp);
else
putq(q, bp);
rs232output(q->ptr);
}
static void
rs232timer(Alarm *a)
{
Rs232 *r;
r = a->arg;
cancel(a);
r->a = 0;
wakeup(&r->r);
}
void
rs232ichar(int c)
{
Rs232 *r;
r = &rs232;
putc(&r->in, c);
if(r->a == 0)
alarm(125, rs232timer, r);
}
int
getrs232o(void)
{
int c;
Rs232 *r;
Block *bp;
r = &rs232;
if(r->out.r == r->out.w){
r->txenabled = 0;
return -1;
}
bp = r->out.bp[r->out.r];
c = *bp->rptr++;
if(bp->rptr >= bp->wptr){
r->out.r = NEXT(r->out.r);
if(r->out.r==r->out.w || NEXT(r->out.r)==r->out.w)
wakeup(&r->r);
}
return c;
.
733c
qunlock(&rs232);
.
715c
qunlock(&rs232);
.
713c
qlock(&rs232);
.
689,709c
n = streamwrite(c, va, n, 1);
.
569,583c
return streamread(c, buf, n);
.
500a
if(c->qid == Qrs232)
streamclose(c);
.
486a
if(c->qid == Qrs232)
streamopen(c, &rs232info);
.
462c
switch(c->qid){
case Qrs232:
streamstat(c, dp, "rs232");
break;
default:
devstat(c, dp, consdir, NCONS, consgen);
break;
}
.
386,389d
357a
Qrs232 = STREAMQID(1, Sdataqid),
.
351d
322,333d
314,320d
72,75d
60,63d
50a
/*
* rs232 stream module
*/
typedef struct Rs232 Rs232;
typedef struct IOBQ IOBQ;
#define NBQ 4
struct IOBQ{
Block *bp[NBQ];
int w;
int r;
int f;
};
#define NEXT(x) ((x+1)%NBQ)
struct Rs232{
QLock;
QLock outlock;
IOQ in;
IOBQ out;
int kstarted; /* true if kproc started */
Queue *wq;
Alarm *a; /* alarm for waking the rs232 kernel process */
int txenabled;
Rendez r;
};
Rs232 rs232;
static void rs232output(Rs232*);
static void rs232input(Rs232*);
static void rs232timer(Alarm*);
static void rs232kproc(void*);
static void rs232open(Queue*, Stream*);
static void rs232close(Queue*);
static void rs232oput(Queue*, Block*);
Qinfo rs232info = { nullput, rs232oput, rs232open, rs232close, "rs232" };
.
34,35d
18,19d
10a
typedef struct IOQ IOQ;
.
## diffname gnot/devcons.c 1990/0901
## diff -e /n/bootesdump/1990/0831/sys/src/9/68020/devcons.c /n/bootesdump/1990/0901/sys/src/9/68020/devcons.c
946c
r->started = 0;
.
940c
uchar c;
.
936a
/*
* called by output interrupt. runs splhi
*/
.
932,934c
if(putc(&r->in, c) < 0)
screenputc('^');
/*
* pass upstream within 1/16 second
*/
if(r->a==0)
r->a = alarm(64, rs232timer, r);
.
925a
/*
* called by input interrupt. runs splhi
*/
.
830a
bp->flags |= S_DELIM;
.
829d
822c
int c;
.
814a
spllo();
.
811,812c
splhi();
if(r->started == 0){
r->started = 1;
.
809c
* start output, the spl's sync with interrupt level
* this wouldn't work on a multi-processor
.
804a
if(bp == 0)
break;
r->out.bp[r->out.w] = bp;
.
801,803c
for(next = NEXT(r->out.w); next!=r->out.r; next = NEXT(next)){
.
72c
int started;
.
55c
#define NBQ 6
.
## diffname gnot/devcons.c 1990/0905
## diff -e /n/bootesdump/1990/0901/sys/src/9/68020/devcons.c /n/bootesdump/1990/0905/sys/src/9/68020/devcons.c
804a
if(bp->type == M_CTL){
while(!rs232empty(r))
sleep(&r->r, rs232empty, r);
l = strtoul((char *)(bp->rptr+1), 0, 0);
switch(*bp->rptr){
case 'B':
duartbaud(l); break;
case 'D':
duartdtr(l); break;
case 'K':
duartbreak(l); break;
}
freeb(bp);
break;
}
.
801c
for(next = NEXT(r->out.w); next != r->out.r; next = NEXT(next)){
.
799a
*
* if we run into a control block, wait till the queue
* is empty before doing the control.
.
791,798d
785a
long l;
.
779a
static int
rs232empty(void *a)
{
Rs232 *r;
r = a;
return r->out.w == r->out.r;
}
.
778a
*
* A kernel process, rs232kproc, stages blocks to be output and
* packages input bytes into stream blocks to send upstream.
* The process is awakened whenever the interrupt side is almost
* out of bytes to xmit or 1/16 second has elapsed since a byte
* was input.
.
694,717d
690a
case Qrs232ctl:
.
500a
break;
}
.
499c
break;
case Qrs232:
case Qrs232ctl:
.
482,489c
switch(c->qid){
case Quser:
if(omode==(OWRITE|OTRUNC)){
/* truncate? */
if(strcmp(u->p->pgrp->user, "bootes") == 0) /* BUG */
u->p->pgrp->user[0] = 0;
else
error(0, Eperm);
}
break;
case Qrcons:
.
365a
Qrs232ctl = STREAMQID(1, Sctlqid),
.
360d
## diffname gnot/devcons.c 1990/0911
## diff -e /n/bootesdump/1990/0905/sys/src/9/68020/devcons.c /n/bootesdump/1990/0911/sys/src/9/68020/devcons.c
955,956c
if(r->a==0){
if(r->delay == 0)
wakeup(&r->r);
else
r->a = alarm(r->delay, rs232timer, r);
}
.
922c
if(bp->rptr >= bp->wptr)
.
810c
case 'k':
duartbreak(l);
break;
case 'W':
case 'w':
if(l>=0 && l<1000)
r->delay = l;
break;
.
808c
case 'd':
duartdtr(l);
break;
.
806c
case 'b':
duartbaud(l);
break;
.
796c
for(next = NEXT(r->out.w); next != r->out.f; next = NEXT(next)){
.
790a
* free old blocks
*/
for(next = r->out.f; next != r->out.r; next = NEXT(next)){
freeb(r->out.bp[next]);
r->out.bp[next] = 0;
}
r->out.f = next;
/*
.
293c
if(c == 0x1A)
.
72a
int delay; /* time between character input and waking kproc */
.
## diffname gnot/devcons.c 1990/0914
## diff -e /n/bootesdump/1990/0911/sys/src/9/68020/devcons.c /n/bootesdump/1990/0914/sys/src/9/68020/devcons.c
107c
lock(&klogq.put); /* allocate lock */
.
100a
rs232.in.in = rs232.in.buf;
rs232.in.out = rs232.in.buf;
.
## diffname gnot/devcons.c 1990/0918
## diff -e /n/bootesdump/1990/0914/sys/src/9/68020/devcons.c /n/bootesdump/1990/0918/sys/src/9/68020/devcons.c
292,297c
if(ctrlt == 2){
ctrlt = 0;
switch(c){
case 0x14:
break; /* pass it on */
case 'p':
DEBUG();
return;
case 'q':
dumpqueues();
return;
case 'm':
mntdump();
return;
}
}else if(c == 0x14){
ctrlt++;
return;
}
ctrlt = 0;
.
287a
static int ctrlt;
.
## diffname gnot/devcons.c 1990/1024
## diff -e /n/bootesdump/1990/0918/sys/src/9/68020/devcons.c /n/bootesdump/1990/1024/sys/src/9/68020/devcons.c
540c
if(c->stream)
.
## diffname gnot/devcons.c 1990/11151
## diff -e /n/bootesdump/1990/1024/sys/src/9/68020/devcons.c /n/bootesdump/1990/11151/sys/src/9/68020/devcons.c
86c
Qinfo rs232info =
{
nullput,
rs232oput,
rs232open,
rs232close,
"rs232"
};
.
## diffname gnot/devcons.c 1990/11211
## diff -e /n/bootesdump/1990/11151/sys/src/9/68020/devcons.c /n/bootesdump/1990/11211/sys/src/9/68020/devcons.c
771,783c
error(Eperm);
.
765c
error(Eperm);
.
757c
error(Egreg);
.
752c
error(Eperm);
.
739c
error(Eperm);
.
704c
switch(c->qid.path){
.
564c
switch(c->qid.path&~CHDIR){
.
545c
if(c->qid.path==Qrcons && (c->flag&COPEN))
.
539c
error(Eperm);
.
514c
error(Eperm);
.
507c
switch(c->qid.path){
.
492c
switch(c->qid.path){
.
395,408c
"cons", {Qcons}, 0, 0600,
"cputime", {Qcputime}, 6*NUMSIZE, 0600,
"null", {Qnull}, 0, 0600,
"pgrpid", {Qpgrpid}, NUMSIZE, 0600,
"pid", {Qpid}, NUMSIZE, 0600,
"ppid", {Qppid}, NUMSIZE, 0600,
"rcons", {Qrcons}, 0, 0600,
"rs232", {Qrs232}, 0, 0600,
"rs232ctl", {Qrs232ctl}, 0, 0600,
"time", {Qtime}, NUMSIZE, 0600,
"user", {Quser}, 0, 0600,
"klog", {Qklog}, 0, 0400,
"msec", {Qmsec}, NUMSIZE, 0400,
"clock", {Qclock}, 2*NUMSIZE, 0400,
.
## diffname gnot/devcons.c 1990/1212
## diff -e /n/bootesdump/1990/11211/sys/src/9/68020/devcons.c /n/bootesdump/1990/1212/sys/src/9/68020/devcons.c
313a
case 'i':
incontoggle();
return;
.
## diffname gnot/devcons.c 1990/1219
## diff -e /n/bootesdump/1990/1212/sys/src/9/68020/devcons.c /n/bootesdump/1990/1219/sys/src/9/68020/devcons.c
337d
## diffname gnot/devcons.c 1991/0112
## diff -e /n/bootesdump/1990/1219/sys/src/9/68020/devcons.c /n/bootesdump/1991/0112/sys/src/9/68020/devcons.c
310a
case 'r':
panic("you asked for it");
break;
.
## diffname gnot/devcons.c 1991/0221
## diff -e /n/bootesdump/1991/0201/sys/src/9/68020/devcons.c /n/bootesdump/1991/0221/sys/src/9/gnot/devcons.c
257a
dumpstack();
.
## diffname gnot/devcons.c 1991/0311
## diff -e /n/bootesdump/1991/0221/sys/src/9/gnot/devcons.c /n/bootesdump/1991/0311/sys/src/9/gnot/devcons.c
118,119d
97a
screeninit();
.
## diffname gnot/devcons.c 1991/0318
## diff -e /n/bootesdump/1991/0311/sys/src/9/gnot/devcons.c /n/bootesdump/1991/0318/sys/src/9/gnot/devcons.c
749c
memmove(u->p->pgrp->user+c->offset, a, n);
.
737c
memmove(cbuf, a, n);
.
720c
memmove(buf, a, m);
.
669c
memmove(buf, tmp+k, n);
.
644c
memmove(buf, tmp+k, n);
.
462c
memmove(buf, str+off, n);
.
448c
memmove(buf, tmp+off, n);
.
## diffname gnot/devcons.c 1991/0411
## diff -e /n/bootesdump/1991/0318/sys/src/9/gnot/devcons.c /n/bootesdump/1991/0411/sys/src/9/gnot/devcons.c
747,750c
if(offset+n >= NAMELEN-1)
n = NAMELEN-1 - offset;
memmove(u->p->pgrp->user+offset, a, n);
u->p->pgrp->user[offset+n] = 0;
.
745c
if(offset >= NAMELEN-1)
.
702c
conswrite(Chan *c, void *va, long n, ulong offset)
.
673c
return readstr(offset, buf, n, u->p->pgrp->user);
.
662c
k = offset;
.
660c
return readnum(offset, buf, n, TK2MS(MACHP(0)->ticks), NUMSIZE);
.
657c
return readnum(offset, buf, n, boottime+TK2SEC(MACHP(0)->ticks), NUMSIZE);
.
654c
return readnum(offset, buf, n, u->p->parentpid, NUMSIZE);
.
651c
return readnum(offset, buf, n, u->p->pid, NUMSIZE);
.
648c
return readnum(offset, buf, n, u->p->pgrp->pgrpid, NUMSIZE);
.
631c
k = offset;
.
625c
if(offset)
.
557c
consread(Chan *c, void *buf, long n, ulong offset)
.
279c
qunlock(&c->wrl);
.
277c
(*devtab[c->type].write)(c, buf, n, c->offset);
.
274c
qunlock(&c->wrl);
.
272c
qlock(&c->wrl);
.
## diffname gnot/devcons.c 1991/0419
## diff -e /n/bootesdump/1991/0411/sys/src/9/gnot/devcons.c /n/bootesdump/1991/0419/sys/src/9/gnot/devcons.c
493a
Chan*
consclwalk(Chan *c, char *name)
{
return devclwalk(c, name);
}
.
## diffname gnot/devcons.c 1991/0423
## diff -e /n/bootesdump/1991/0419/sys/src/9/gnot/devcons.c /n/bootesdump/1991/0423/sys/src/9/gnot/devcons.c
1028a
r->started = 1;
.
1018a
wakeup(&r->rempty);
.
1008c
* called by output interrupt. runs spl5
.
997c
* pass upstream within r->delay milliseconds
.
957a
qlock(&r->outlock);
while(!rs232empty(r))
sleep(&r->rempty, rs232empty, r);
qunlock(&r->outlock);
kprint("rs232close: emptied\n");
rs232output(r); /* reclaim blocks written */
.
956a
kprint("rs232close: q=0x%ux\n", q);
.
949c
}else
wakeup(&r->r); /* pick up any input characters */
.
944a
kprint("rs232open: q=0x%ux, inuse=%d, type=%d, dev=%d, id=%d\n",
q, c->inuse, c->type, c->dev, c->id);
.
871,872d
867,869c
if(r->started == 0)
.
855a
poperror();
.
835c
sleep(&r->rempty, rs232empty, r);
.
833a
if(waserror()){
freeb(bp);
qunlock(&r->outlock);
nexterror();
}
.
822a
if(q==0){
kprint("rs232output: null q\n");
qunlock(&r->outlock);
return;
}
.
702c
panic("consread %lux\n", c->qid.path);
.
339a
.
295a
extern void DEBUG(void), dumpqueues(void), mntdump(void);
.
110a
rs232.delay = 64; /* msec */
.
74a
Rendez rempty;
.
72c
int started; /* true if output interrupt pending */
.
## diffname gnot/devcons.c 1991/0427
## diff -e /n/bootesdump/1991/0423/sys/src/9/gnot/devcons.c /n/bootesdump/1991/0427/sys/src/9/gnot/devcons.c
498,503d
## diffname gnot/devcons.c 1991/0514
## diff -e /n/bootesdump/1991/0427/sys/src/9/gnot/devcons.c /n/bootesdump/1991/0514/sys/src/9/gnot/devcons.c
1010c
/*screenputc('^')*/;
.
73c
int delay; /* between character input and waking kproc */
.
## diffname gnot/devcons.c 1991/0605
## diff -e /n/bootesdump/1991/0514/sys/src/9/gnot/devcons.c /n/bootesdump/1991/0605/sys/src/9/gnot/devcons.c
781,1047d
764a
case Qnoise:
consnoise(a, n);
break;
case Qlights:
conslights(a, n);
break;
case Qsysstat:
for(id = 0; id < 32; id++) {
if(active.machs & (1<<id)) {
mp = MACHP(id);
mp->cs = 0;
mp->intr = 0;
mp->syscall = 0;
mp->pfault = 0;
mp->tlbfault = 0;
mp->tlbpurge = 0;
mp->spinlock = 0;
}
}
break;
.
731,735d
715a
case Qcons:
.
714d
711a
Mach *mp;
int id;
.
704a
void
conslights(char *a, int n)
{
int l;
char line[128];
char *lp;
int c;
lp = line;
while(n--){
*lp++ = c = *a++;
if(c=='\n' || n==0 || lp==&line[sizeof(line)-1])
break;
}
*lp = 0;
lights(strtoul(line, 0, 0));
}
void
consnoise(char *a, int n)
{
int freq;
int duration;
char line[128];
char *lp;
int c;
lp = line;
while(n--){
*lp++ = c = *a++;
if(c=='\n' || n==0 || lp==&line[sizeof(line)-1]){
*lp = 0;
freq = strtoul(line, &lp, 0);
while(*lp==' ' || *lp=='\t')
lp++;
duration = strtoul(lp, &lp, 0);
buzz(freq, duration);
lp = line;
}
}
}
.
700c
panic("consread %lux\n", c->qid);
.
698a
case Qmsec:
return readnum(offset, buf, n, TK2MS(MACHP(0)->ticks), NUMSIZE);
case Qsysstat:
j = 0;
for(id = 0; id < 32; id++) {
if(active.machs & (1<<id)) {
mp = MACHP(id);
j += sprint(&xbuf[j], "%d %d %d %d %d %d %d %d\n",
id, mp->cs, mp->intr, mp->syscall, mp->pfault,
mp->tlbfault, mp->tlbpurge, m->spinlock);
}
}
return readstr(offset, buf, n, xbuf);
.
663,664d
661c
return readnum(offset, buf, n, boottime+TK2SEC(MACHP(0)->ticks), 12);
.
625,633d
608a
else
lineq.in++;
.
606,607c
*lineq.in = ch;
if(lineq.in >= lineq.buf+sizeof(lineq.buf)-1)
.
575c
return devdirread(c, buf, n, consdir, NCONS, devgen);
.
573c
switch(c->qid.path & ~CHDIR){
.
569c
char tmp[6*NUMSIZE], xbuf[1024];
Mach *mp;
.
563c
int ch, i, j, k, id;
.
559a
.
556,557d
542c
return devopen(c, omode, consdir, NCONS, devgen);
.
537,540d
501,508c
devstat(c, dp, consdir, NCONS, devgen);
.
495c
return devwalk(c, name, consdir, NCONS, devgen);
.
422,431d
417a
"sysstat", {Qsysstat}, 0, 0600,
.
411,412d
405a
"lights", {Qlights}, 0, 0600,
"noise", {Qnoise}, 0, 0600,
.
399,400c
Qsysstat,
.
388a
Qlights,
Qnoise,
.
379c
return printq.in != printq.out;
.
372,373c
if(kbdq.repeat == 0)
return;
if(kbdq.repeat==1 && ++kbdq.count>HZ){
kbdq.repeat = 2;
kbdq.count = 0;
return;
}
if(++kbdq.count&1)
kbdputc(&kbdq, kbdq.c);
.
363,366c
kbdq.repeat = rep;
kbdq.count = 0;
.
357a
return 0;
.
356c
if(raw.ref || ch=='\n' || ch==0x04)
.
347,353c
echo(ch);
kbdq.c = ch;
*kbdq.in++ = ch;
.
343,345c
int
kbdputc(IOQ *q, int ch)
.
317,322d
315c
firmware();
.
307a
case 'm':
mntdump();
return;
.
298d
289,290c
while(printq.in != printq.out) ;
.
261a
.
260c
for(;;);
.
245c
klogputs(buf, n);
.
177,221d
144,161d
142c
isbrkc(KIOQ *q)
.
138a
wakeup(&klogq.r);
.
132,137c
lock(&klogq);
while(n){
m = &klogq.buf[NQ] - klogq.in;
if(m > n)
m = n;
memmove(klogq.in, str, m);
n -= m;
str += m;
nextin = klogq.in + m;
if(nextin >= &klogq.buf[NQ])
klogq.in = klogq.buf;
else
klogq.in = nextin;
}
unlock(&klogq);
.
129c
int s, m;
uchar *nextin;
.
127c
klogputs(char *str, long n)
.
124c
* Print a string in the kernel log. Ignore overflow.
.
101,120c
while(n > 0){
if(printq.puts && *str=='\n')
(*printq.puts)(&printq, "\r", 1);
m = n;
t = memchr(str+1, '\n', m-1);
if(t)
if(t-str < m)
m = t - str;
if(printq.puts)
(*printq.puts)(&printq, str, m);
screenputs(str, m);
n -= m;
str += m;
}
.
99c
int s, c, m;
char *t;
.
97c
putstrn(char *str, int n)
.
95a
/*
* Print a string on the console. Convert \n to \r\n
*/
.
89,94c
initq(&printq);
initq(&lineq);
initq(&kbdq);
initq(&klogq);
initq(&mouseq);
mouseq.putc = mouseputc;
}
.
52,87c
void
printinit(void)
.
50c
* init the queues and set the output routine
.
20,46d
13,18c
IOQ lineq; /* lock to getc; interrupt putc's */
IOQ printq;
IOQ mouseq;
KIOQ kbdq;
.
11c
struct {
IOQ; /* lock to klogputs */
QLock; /* qlock to getc */
} klogq;
.
## diffname gnot/devcons.c 1991/0608 # deleted
## diff -e /n/bootesdump/1991/0605/sys/src/9/gnot/devcons.c /n/bootesdump/1991/0608/sys/src/9/gnot/devcons.c
1,715d
|
