Subversion Repositories planix.SVN

/*

 * kirkwood two-wire serial interface (TWSI) and

 * inter-integrated circuit (I⁲C) driver

 */

#include "u.h"

#include "../port/lib.h"

#include "mem.h"

#include "dat.h"

#include "fns.h"

#include "../port/error.h"

#include "io.h"

enum {

	Qdir,

	Qtwsi,

};

typedef struct Kwtwsi Kwtwsi;

typedef struct Twsi Twsi;

struct Kwtwsi {				/* device registers */

	ulong	saddr;

	ulong	data;

	ulong	ctl;

	union {

		ulong	status;		/* ro */

		ulong	rate;		/* wo: baud rate */

	};

	ulong	saddrext;

	uchar	_pad0[0x1c-0x14];

	ulong	reset;

	uchar	_pad1[0x98-0x20];

	ulong	initlastdata;

};

enum {

	Twsidowrite,

	Twsidoread,

	/* ctl bits */

	Twsiack		= 1<<2,		/* recv'd data; clear to ack */

	Twsiint		= 1<<3,		/* interrupt conditions true */

	Twsistop	= 1<<4,		

	Twsistart	= 1<<5,

	Twsislaveen	= 1<<6,

	Twsiinten	= 1<<7,		/* interrupts enabled */

	/* status codes */

	SStart	= 0x08,

	SWa	= 0x18,

	SWda	= 0x28,

	SRa	= 0x40,

	SRda	= 0x50,

	SRna	= 0x58,

};

struct Twsi {

	QLock;

	Rendez	nextbyte;

	/* remainder is state needed to track the operation in progress */

	int	intr;

	int	done;

	uchar	*bp;			/* current ptr into buf */

	uchar	*end;

	ulong	addr;			/* device address */

	char	*error;

};

static Twsi twsi;

static Dirtab twsidir[] = {

	".",	{Qdir, 0, QTDIR},	0,	DMDIR|0555,

	"twsi",	{Qtwsi},		0,	0660,

};

static char Eabsts[] = "abnormal status";

static void

twsifinish(void)

{

	Kwtwsi *krp = (Kwtwsi *)soc.twsi;

	twsi.done = 1;

	krp->ctl |= Twsistop;

	coherence();

}

static void

twsidoread(void)

{

	Kwtwsi *krp = (Kwtwsi *)soc.twsi;

	switch(krp->status){

	case SStart:

		krp->data = twsi.addr << 1 | Twsidoread;

		break;

	case SRa:

		krp->ctl |= Twsiack;

		break;

	case SRda:

		if(twsi.bp < twsi.end) {

			*twsi.bp++ = krp->data;

			krp->ctl |= Twsiack;

		} else

			krp->ctl &= ~Twsiack;

		break;

	case SRna:

		twsifinish();

		break;

	default:

		twsifinish();

		twsi.error = Eabsts;

		break;

	}

}

static void

twsidowrite(void)

{

	Kwtwsi *krp = (Kwtwsi *)soc.twsi;

	switch(krp->status){

	case SStart:

		krp->data = twsi.addr << 1 | Twsidowrite;

		break;

	case SWa:

	case SWda:

		if(twsi.bp < twsi.end)

			krp->data = *twsi.bp++;

		else

			twsifinish();

		break;

	default:

		twsifinish();

		twsi.error = Eabsts;

		break;

	}

}

static int

twsigotintr(void *)

{

	return twsi.intr;

}

static long

twsixfer(uchar *buf, ulong len, ulong offset, void (*op)(void))

{

	ulong off;

	char *err;

	Kwtwsi *krp = (Kwtwsi *)soc.twsi;

	qlock(&twsi);

	twsi.bp = buf;

	twsi.end = buf + len;

	twsi.addr = offset;

	twsi.done = twsi.intr = 0;

	twsi.error = nil;

	krp->ctl = (krp->ctl & ~Twsiint) | Twsistart;

	coherence();

	while (!twsi.done) {

		sleep(&twsi.nextbyte, twsigotintr, 0);

		twsi.intr = 0;

		(*op)();

		/* signal to start new op & extinguish intr source */

		krp->ctl &= ~Twsiint;

		coherence();

		krp->ctl |= Twsiinten;

		coherence();

	}

	twsifinish();

	err = twsi.error;

	off = twsi.bp - buf;

	twsi.bp = nil;				/* prevent accidents */

	qunlock(&twsi);

	if(err)

		error(err);

	return off;

}

static void

interrupt(Ureg *, void *)

{

	Kwtwsi *krp = (Kwtwsi *)soc.twsi;

	twsi.intr = 1;

	wakeup(&twsi.nextbyte);

	krp->ctl &= ~Twsiinten;			/* stop further interrupts */

	coherence();

	intrclear(Irqlo, IRQ0twsi);

}

static void

twsiinit(void)

{

	Kwtwsi *krp = (Kwtwsi *)soc.twsi;

	intrenable(Irqlo, IRQ0twsi, interrupt, nil, "twsi");

	krp->ctl &= ~Twsiint;

	krp->ctl |= Twsiinten;

	coherence();

}

static void

twsishutdown(void)

{

	Kwtwsi *krp = (Kwtwsi *)soc.twsi;

	krp->ctl &= ~Twsiinten;

	coherence();

	intrdisable(Irqlo, IRQ0twsi, interrupt, nil, "twsi");

}

static Chan*

twsiattach(char *param)

{

	return devattach(L'⁲', param);

}

static Walkqid*

twsiwalk(Chan *c, Chan *nc, char **name, int nname)

{

	return devwalk(c, nc, name, nname, twsidir, nelem(twsidir), devgen);

}

static int

twsistat(Chan *c, uchar *db, int n)

{

	return devstat(c, db, n, twsidir, nelem(twsidir), devgen);

}

static Chan*

twsiopen(Chan *c, int omode)

{

	switch((ulong)c->qid.path){

	default:

		error(Eperm);

	case Qdir:

	case Qtwsi:

		break;

	}

	c = devopen(c, omode, twsidir, nelem(twsidir), devgen);

	c->mode = openmode(omode);

	c->flag |= COPEN;

	c->offset = 0;

	return c;

}

static void

twsiclose(Chan *)

{

}

static long

twsiread(Chan *c, void *v, long n, vlong off)

{

	switch((ulong)c->qid.path){

	default:

		error(Eperm);

	case Qdir:

		return devdirread(c, v, n, twsidir, nelem(twsidir), devgen);

	case Qtwsi:

		return twsixfer(v, n, off, twsidoread);

	}

}

static long

twsiwrite(Chan *c, void *v, long n, vlong off)

{

	switch((ulong)c->qid.path){

	default:

		error(Eperm);

	case Qtwsi:

		return twsixfer(v, n, off, twsidowrite);

	}

}

Dev twsidevtab = {

	L'⁲',

	"twsi",

	devreset,

	twsiinit,

	twsishutdown,

	twsiattach,

	twsiwalk,

	twsistat,

	twsiopen,

	devcreate,

	twsiclose,

	twsiread,

	devbread,

	twsiwrite,

	devbwrite,

	devremove,

	devwstat,

};