ref: 0c36c79e9b58b5131d4911b05ede987ce0bb8bde
dir: /sys/src/9/bitsy/devµc.c/
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "io.h"
#include "../port/error.h"
enum{
Qdir,
Qbacklight,
Qbattery,
Qbuttons,
Qcruft,
Qled,
Qversion,
Qpower,
/* command types */
BLversion= 0,
BLbuttons= 2, /* button events */
BLtouch= 3, /* read touch screen events */
BLled= 8, /* turn LED on/off */
BLbattery= 9, /* read battery status */
BLbacklight= 0xd, /* backlight control */
SOF= 0x2, /* start of frame */
};
Dirtab µcdir[]={
".", { Qdir, 0, QTDIR }, 0, DMDIR|0755,
"backlight", { Qbacklight, 0 }, 0, 0664,
"battery", { Qbattery, 0 }, 0, 0664,
"buttons", { Qbuttons, 0 }, 0, 0664,
"cruft", { Qcruft, 0 }, 0, 0664,
"led", { Qled, 0 }, 0, 0664,
"version", { Qversion, 0 }, 0, 0664,
"power", { Qpower, 0 }, 0, 0600,
};
static struct µcontroller
{
/* message being rcvd */
int state;
uchar buf[16+4];
uchar n;
/* for messages that require acks */
QLock;
Rendez r;
/* battery */
uchar acstatus;
uchar voltage;
ushort batstatus;
uchar batchem;
/* version string */
char version[16+2];
} ctlr;
extern int landscape;
int
µcputc(Queue*, int ch)
{
int i, len, b, up;
uchar cksum;
uchar *p;
static int samseq;
static int touching; /* guard against something we call going spllo() */
static int buttoning; /* guard against something we call going spllo() */
if(ctlr.n > sizeof(ctlr.buf))
panic("µcputc");
ctlr.buf[ctlr.n++] = (uchar)ch;
for(;;){
/* message hasn't started yet? */
if(ctlr.buf[0] != SOF){
p = memchr(ctlr.buf, SOF, ctlr.n);
if(p == nil){
ctlr.n = 0;
break;
} else {
ctlr.n -= p-ctlr.buf;
memmove(ctlr.buf, p, ctlr.n);
}
}
/* whole msg? */
len = ctlr.buf[1] & 0xf;
if(ctlr.n < 3 || ctlr.n < len+3)
break;
/* check the sum */
ctlr.buf[0] = ~SOF; /* make sure we process this msg exactly once */
cksum = 0;
for(i = 1; i < len+2; i++)
cksum += ctlr.buf[i];
if(ctlr.buf[len+2] != cksum)
continue;
/* parse resulting message */
p = ctlr.buf+2;
switch(ctlr.buf[1] >> 4){
case BLversion:
strncpy(ctlr.version, (char*)p, len);
ctlr.version[len] = '0';
strcat(ctlr.version, "\n");
wakeup(&ctlr.r);
break;
case BLbuttons:
if(len < 1 || buttoning)
break;
buttoning = 1;
b = p[0] & 0x7f;
up = p[0] & 0x80;
if(b <= 5){
/* like mouse buttons */
if(--b == 0)
b = 5;
penbutton(up, 1<<b);
}
buttoning = 0;
break;
case BLtouch:
if(touching)
break;
touching = 1;
if(len == 4) {
if (samseq++ > 10){
if (landscape)
pentrackxy((p[0]<<8)|p[1], (p[2]<<8)|p[3]);
else
pentrackxy((p[2]<<8)|p[3], (p[0]<<8)|p[1]);
}
} else {
samseq = 0;
pentrackxy(-1, -1);
}
touching = 0;
break;
case BLled:
wakeup(&ctlr.r);
break;
case BLbattery:
if(len >= 5){
ctlr.acstatus = p[0];
ctlr.voltage = (p[3]<<8)|p[2];
ctlr.batstatus = p[4];
ctlr.batchem = p[1];
}
wakeup(&ctlr.r);
break;
case BLbacklight:
wakeup(&ctlr.r);
break;
default:
print("unknown µc message: %ux", ctlr.buf[1] >> 4);
for(i = 0; i < len; i++)
print(" %ux", p[i]);
print("\n");
break;
}
/* remove the message */
ctlr.n -= len+3;
memmove(ctlr.buf, &ctlr.buf[len+3], ctlr.n);
}
return 0;
}
static void
_sendmsg(uchar id, uchar *data, int len)
{
uchar buf[20];
uchar cksum;
uchar c;
uchar *p = buf;
int i;
/* create the message */
if(sizeof(buf) < len+4)
return;
cksum = (id<<4) | len;
*p++ = SOF;
*p++ = cksum;
for(i = 0; i < len; i++){
c = data[i];
cksum += c;
*p++ = c;
}
*p++ = cksum;
/* send the message - there should be a more generic way to do this */
serialµcputs(buf, p-buf);
}
/* the tsleep takes care of lost acks */
static void
sendmsgwithack(uchar id, uchar *data, int len)
{
if(waserror()){
qunlock(&ctlr);
nexterror();
}
qlock(&ctlr);
_sendmsg(id, data, len);
tsleep(&ctlr.r, return0, 0, 100);
qunlock(&ctlr);
poperror();
}
static void
sendmsg(uchar id, uchar *data, int len)
{
if(waserror()){
qunlock(&ctlr);
nexterror();
}
qlock(&ctlr);
_sendmsg(id, data, len);
qunlock(&ctlr);
poperror();
}
void
µcinit(void)
{
}
static Chan*
µcattach(char* spec)
{
return devattach('r', spec);
}
static Walkqid*
µcwalk(Chan *c, Chan *nc, char **name, int nname)
{
return devwalk(c, nc, name, nname, µcdir, nelem(µcdir), devgen);
}
static int
µcstat(Chan *c, uchar *dp, int n)
{
return devstat(c, dp, n, µcdir, nelem(µcdir), devgen);
}
static Chan*
µcopen(Chan* c, int omode)
{
omode = openmode(omode);
if(!iseve())
error(Eperm);
return devopen(c, omode, µcdir, nelem(µcdir), devgen);
}
static void
µcclose(Chan*)
{
}
char*
acstatus(int x)
{
if(x)
return "attached";
else
return "detached";
}
char*
batstatus(int x)
{
switch(x){
case 1: return "high";
case 2: return "low";
case 4: return "critical";
case 8: return "charging";
case 0x80: return "none";
}
return "ok";
}
static long
µcread(Chan* c, void* a, long n, vlong off)
{
char buf[64];
if(c->qid.path == Qdir)
return devdirread(c, a, n, µcdir, nelem(µcdir), devgen);
switch((ulong)c->qid.path){
case Qbattery:
sendmsgwithack(BLbattery, nil, 0); /* send a battery request */
sprint(buf, "voltage: %d\nac: %s\nstatus: %s\n", ctlr.voltage,
acstatus(ctlr.acstatus),
batstatus(ctlr.batstatus));
return readstr(off, a, n, buf);
case Qversion:
sendmsgwithack(BLversion, nil, 0); /* send a battery request */
return readstr(off, a, n, ctlr.version);
}
error(Ebadarg);
return 0;
}
#define PUTBCD(n,o) bcdclock[o] = (n % 10) | (((n / 10) % 10)<<4)
static uchar lightdata[16];
static long
µcwrite(Chan* c, void* a, long n, vlong)
{
Cmdbuf *cmd;
uchar data[16];
char str[64];
int i, j;
ulong l;
Rune r;
extern ulong resumeaddr[];
extern void power_resume(void);
if(c->qid.path == Qpower){
if(!iseve())
error(Eperm);
if(strncmp(a, "suspend", 7) == 0)
*resumeaddr = (ulong)power_resume;
else if(strncmp(a, "halt", 4) == 0)
*resumeaddr = 0;
else if(strncmp(a, "wakeup", 6) == 0){
cmd = parsecmd(a, n);
if (cmd->nf != 2)
error(Ebadarg);
l = strtoul(cmd->f[1], 0, 0);
rtcalarm(l);
return n;
} else
error(Ebadarg);
deepsleep();
return n;
}
cmd = parsecmd(a, n);
if(cmd->nf > 15)
error(Ebadarg);
for(i = 0; i < cmd->nf; i++)
data[i] = strtol(cmd->f[i], 0, 0);
switch((ulong)c->qid.path){
case Qled:
sendmsgwithack(BLled, data, cmd->nf);
break;
case Qbacklight:
memmove(lightdata, data, 16);
sendmsgwithack(BLbacklight, data, cmd->nf);
break;
case Qcruft:
// lcdtweak(cmd);
break;
default:
error(Ebadarg);
}
return n;
}
void
µcpower(int on)
{
uchar data[16];
if (on == 0)
return;
/* maybe dangerous, not holding the lock */
if (lightdata[0] == 0){
data[0]= 2;
data[1]= 1;
data[2]= 0;
} else
memmove(data, lightdata, 16);
_sendmsg(0xd, data, 3);
wakeup(&ctlr.r);
}
Dev µcdevtab = {
'r',
"µc",
devreset,
µcinit,
devshutdown,
µcattach,
µcwalk,
µcstat,
µcopen,
devcreate,
µcclose,
µcread,
devbread,
µcwrite,
devbwrite,
devremove,
devwstat,
};