ref: 54bac038f411c10a596adf84c06df32f8c7c4c53
dir: /os/mpc/devtouch.c/
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "io.h"
#include "../port/error.h"
#define DPRINT if(0)print
#define THREEBUT 0 /* !=0, enable 3-button emulation (see below) */
/*
* DynaPro touch panel and Maxim MAX192 A/D converter on
* York Electronics Centre's BRD/98/024 (Version A) interface,
* accessed via mpc8xx SPI interface (see spi.c).
*
* The highest level of the driver is derived from the ARM/UCB touch panel driver,
* simplified because of the differences between the panels.
*/
/*
* Values determined by interface board
*/
enum {
/* MAX192 control words */
MeasureX = (1<<7)|(0<<6)|(1<<3)|(1<<2)|3, /* start, channel 0, unipolar, single-ended, external clock */
MeasureY = (1<<7)|(1<<6)|(1<<3)|(1<<2)|3, /* start, channel 1, unipolar, single-ended, external clock */
/* port B bits */
ADselect = IBIT(16), /* chip select to MAX192, active low */
/* port C bits */
Xenable = 1<<2, /* PC13: TOUCH_XEN, active low */
Yenable = 1<<3, /* PC12: TOUCH_YEN, active low */
Touched = 1<<10, /* PC5: contact detect, active low */
/* interrupt control via port C */
TouchIRQ= 2, /* parallel i/o - PC5 */
TouchEnable= 1<<TouchIRQ, /* mask for cimr */
/* other parameters */
Nconverge = 10, /* maximum iterations for convergence */
MaxDelta = 2, /* acceptable change in X/Y between iterations */
};
/*
* ADC interface via SPI (see MAX192 data sheet)
* select the ADC
* send 8-bit control word and two zero bytes to clock the conversion
* receive three data bytes
* deselect the ADC and return the result
*/
static int
getcoord(int cw)
{
uchar tbuf[3], rbuf[3];
IMM *io;
int nr;
tbuf[0] = cw;
tbuf[1] = 0;
tbuf[2] = 0;
io = ioplock();
io->pbdat &= ~ADselect;
iopunlock();
nr = spioutin(tbuf, sizeof(tbuf), rbuf);
io = ioplock();
io->pbdat |= ADselect;
iopunlock();
if(nr != 3)
return -1;
return ((rbuf[1]<<8)|rbuf[2])>>5;
}
/*
* keep reading the a/d until the value stabilises
*/
static int
dejitter(int enable, int cw)
{
int i, diff, prev, v;
IMM *io;
io = ioplock();
io->pcdat &= ~enable; /* active low */
iopunlock();
i = 0;
v = getcoord(cw);
do{
prev = v;
v = getcoord(cw);
diff = v - prev;
if(diff < 0)
diff = -diff;
}while(diff >= MaxDelta && ++i <= Nconverge);
io = ioplock();
io->pcdat |= enable;
iopunlock();
return v;
}
static void
adcreset(void)
{
IMM *io;
/* select port pins */
io = ioplock();
io->pcdir &= ~(Xenable|Yenable); /* ensure set to input before changing state */
io->pcpar &= ~(Xenable|Yenable);
io->pcdat |= Xenable|Yenable;
io->pcdir |= Xenable; /* change enable bits to output one at a time to avoid both being low at once (could damage panel) */
io->pcdat |= Xenable; /* ensure it's high after making it an output */
io->pcdir |= Yenable;
io->pcdat |= Yenable; /* ensure it's high after making it an output */
io->pcso &= ~(Xenable|Yenable);
io->pbdat |= ADselect;
io->pbpar &= ~ADselect;
io->pbdir |= ADselect;
iopunlock();
}
/*
* high-level touch panel interface
*/
/* to and from fixed point */
#define FX(n) ((n)<<16)
#define XF(v) ((v)>>16)
typedef struct Touch Touch;
struct Touch {
Lock;
Rendez r;
int m[2][3]; /* transformation matrix */
int rate;
int down;
int raw_count;
int valid_count;
int wake_time;
int sleep_time;
};
static Touch touch = {
{0},
.r {0},
.m {{FX(1), 0, 0},{0, FX(1), 0}}, /* default is 1:1 */
.rate 20, /* milliseconds */
};
/*
* panel-touched state and interrupt
*/
static int
touching(void)
{
eieio();
return (m->iomem->pcdat & Touched) == 0;
}
static int
ispendown(void*)
{
return touch.down || touching();
}
static void
touchintr(Ureg*, void*)
{
if((m->iomem->pcdat & Touched) == 0){
m->iomem->cimr &= ~TouchEnable; /* mask interrupts when reading pen */
touch.down = 1;
wakeup(&touch.r);
}
}
static void
touchenable(void)
{
IMM *io;
io = ioplock();
io->cimr |= TouchEnable;
iopunlock();
}
/*
* touchctl commands:
* X a b c - set X transformation
* Y d e f - set Y transformation
* s<delay> - set sample delay in millisec per sample
* r<delay> - set read delay in microsec
* R<l2nr> - set log2 of number of readings to average
*/
enum{
Qdir,
Qtouchctl,
Qtouchstat,
Qtouch,
};
Dirtab touchdir[]={
".", {Qdir, 0, QTDIR}, 0, 0555,
"touchctl", {Qtouchctl, 0}, 0, 0666,
"touchstat", {Qtouchstat, 0}, 0, 0444,
"touch", {Qtouch, 0}, 0, 0444,
};
static int
ptmap(int *m, int x, int y)
{
return XF(m[0]*x + m[1]*y + m[2]);
}
/*
* read a point from the touch panel;
* returns true iff the point is valid, otherwise x, y aren't changed
*/
static int
touchreadxy(int *fx, int *fy)
{
int rx, ry;
if(touching()){
rx = dejitter(Xenable, MeasureX);
ry = dejitter(Yenable, MeasureY);
microdelay(40);
if(rx >=0 && ry >= 0){
if(0)
print("touch %d %d\n", rx, ry);
*fx = ptmap(touch.m[0], rx, ry);
*fy = ptmap(touch.m[1], rx, ry);
touch.raw_count++;
return 1;
}
}
return 0;
}
#define timer_start() 0 /* could use TBL if necessary */
#define tmr2us(n) 0
static void
touchproc(void*)
{
int b, i, x, y;
ulong t1, t2;
t1 = timer_start();
b = 1;
for(;;) {
//setpri(PriHi);
do{
touch.down = 0;
touch.wake_time += (t2 = timer_start())-t1;
touchenable();
sleep(&touch.r, ispendown, nil);
touch.sleep_time += (t1 = timer_start())-t2;
}while(!touchreadxy(&x, &y));
/* 640x480-specific 3-button emulation hack: */
if(THREEBUT){
if(y > 481) {
b = ((639-x) >> 7);
continue;
} else if(y < -2) {
b = (x >> 7)+3;
continue;
}
}
DPRINT("#%d %d", x, y);
mousetrack(b, x, y, 0);
setpri(PriNormal);
while(touching()) {
for(i=0; i<3; i++)
if(touchreadxy(&x, &y)) {
DPRINT("*%d %d", x, y);
mousetrack(b, x, y, 0);
break;
}
touch.wake_time += (t2 = timer_start())-t1;
tsleep(&touch.r, return0, nil, touch.rate);
touch.sleep_time += (t1 = timer_start())-t2;
}
mousetrack(0, x, y, 0);
b = 1; /* go back to just button one for next press */
}
}
static void
touchreset(void)
{
IMM *io;
spireset();
adcreset();
intrenable(VectorCPIC+TouchIRQ, touchintr, &touch, BUSUNKNOWN, "touch");
/* set i/o pin to interrupt when panel touched */
io = ioplock();
io->pcdat &= ~Touched;
io->pcpar &= ~Touched;
io->pcdir &= ~Touched;
io->pcso &= ~Touched;
io->pcint |= Touched; /* high-to-low trigger */
io->cimr &= ~TouchEnable; /* touchproc will enable when ready */
iopunlock();
}
static void
touchinit(void)
{
static int done;
if(!done){
done = 1;
kproc( "touchscreen", touchproc, nil, 0);
}
}
static Chan*
touchattach(char* spec)
{
return devattach('T', spec);
}
static Walkqid*
touchwalk(Chan* c, Chan *nc, char **name, int nname)
{
return devwalk(c, nc, name, nname, touchdir, nelem(touchdir), devgen);
}
static int
touchstat(Chan* c, uchar* dp, int n)
{
return devstat(c, dp, n, touchdir, nelem(touchdir), devgen);
}
static Chan*
touchopen(Chan* c, int omode)
{
omode = openmode(omode);
switch((ulong)c->qid.path){
case Qtouchctl:
case Qtouchstat:
if(!iseve())
error(Eperm);
break;
}
return devopen(c, omode, touchdir, nelem(touchdir), devgen);
}
static void
touchclose(Chan*)
{
}
static long
touchread(Chan* c, void* buf, long n, vlong offset)
{
char *tmp;
int x, y;
if(c->qid.type & QTDIR)
return devdirread(c, buf, n, touchdir, nelem(touchdir), devgen);
tmp = malloc(READSTR);
if(waserror()){
free(tmp);
nexterror();
}
switch((ulong)c->qid.path){
case Qtouch:
if(!touchreadxy(&x, &y))
x = y = -1;
snprint(tmp, READSTR, "%d %d", x, y);
break;
case Qtouchctl:
snprint(tmp, READSTR, "s%d\nr%d\nR%d\nX %d %d %d\nY %d %d %d\n",
touch.rate, 0, 1,
touch.m[0][0], touch.m[0][1], touch.m[0][2],
touch.m[1][0], touch.m[1][1], touch.m[1][2]);
break;
case Qtouchstat:
snprint(tmp, READSTR, "%d %d\n%d %d\n",
touch.raw_count, touch.valid_count, tmr2us(touch.sleep_time), tmr2us(touch.wake_time));
touch.raw_count = 0;
touch.valid_count = 0;
touch.sleep_time = 0;
touch.wake_time = 0;
break;
default:
error(Ebadarg);
return 0;
}
n = readstr(offset, buf, n, tmp);
poperror();
free(tmp);
return n;
}
static void
dotouchwrite(Chan *c, char *buf)
{
char *field[8];
int nf, cmd, pn, m[3], n;
nf = getfields(buf, field, nelem(field), 1, " \t\n");
if(nf <= 0)
return;
switch((ulong)c->qid.path){
case Qtouchctl:
cmd = *(field[0])++;
pn = *field[0] == 0;
switch(cmd) {
case 's':
n = strtol(field[pn], 0, 0);
if(n <= 0)
error(Ebadarg);
touch.rate = n;
break;
case 'r':
/* touch read delay */
break;
case 'X':
case 'Y':
if(nf < pn+2)
error(Ebadarg);
m[0] = strtol(field[pn], 0, 0);
m[1] = strtol(field[pn+1], 0, 0);
m[2] = strtol(field[pn+2], 0, 0);
memmove(touch.m[cmd=='Y'], m, sizeof(touch.m[0]));
break;
case 'c':
case 'C':
case 'v':
case 't':
case 'e':
/* not used */
/* break; */
default:
error(Ebadarg);
}
break;
default:
error(Ebadarg);
return;
}
}
static long
touchwrite(Chan* c, void* vp, long n, vlong)
{
char buf[64];
char *cp, *a;
int n0 = n;
int bn;
a = vp;
while(n) {
bn = (cp = memchr(a, '\n', n))!=nil ? cp-a+1 : n;
n -= bn;
bn = bn > sizeof(buf)-1 ? sizeof(buf)-1 : bn;
memmove(buf, a, bn);
buf[bn] = '\0';
a = cp;
dotouchwrite(c, buf);
}
return n0-n;
}
Dev touchdevtab = {
'T',
"touch",
touchreset,
touchinit,
devshutdown,
touchattach,
touchwalk,
touchstat,
touchopen,
devcreate,
touchclose,
touchread,
devbread,
touchwrite,
devbwrite,
devremove,
devwstat,
};