Subversion Repositories planix.SVN

//
// channel element driver
//
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "io.h"
#include "../port/error.h"
#include "msaturn.h"

enum{
        Ucuunknown = 0,
        Ucu64,

        Ndsp = 16,

        Cedead = 0,
        Cereset,
        Celoaded,
        Cerunning,
        
        Qdir = 0,
        Qctl,
        Qce,

        Cpldbase = Saturn + 0x6000000,
                Cplducuversion_ucu = 0x1c,
        Cebase = Saturn + 0x3000000,
        Cesize = 0x100000,
};

typedef struct Cpld Cpld;
struct Cpld{
        uchar   led;
        uchar   fpga1;
        uchar   slotid;
        uchar   version;
        uchar   watchdog;
        uchar   spi;
        uchar   asicreset;
        uchar   dspreset;
        uchar   generalreset;
        uchar   ucuversion;
        uchar   fpga2;
};

typedef struct Circbuf Circbuf;
struct Circbuf{
        uchar   *nextin;
        uchar   *nextout;
        uchar   *start;
        uchar   *end;
};

typedef struct Dsp Dsp;
struct Dsp{
        Ref;
        int             state;
        Circbuf *cb;
};

typedef struct Ce Ce;
struct Ce{
        int             ucutype;
        Ce              *ces[Ndsp];
};

static Cpld*cpld = (Cpld*)Cpldbase;
static Ce ce;

static void
ceinit(void)
{
        if(cpld->ucuversion & Cplducuversion_ucu)
                ce.ucutype = Ucu64;
        else{
                print("ceinit: unsuppoerted UCU\n");
                return;
        }

}

static Chan*
ceattach(char*spec)
{
        return devattach('C', spec);
}

#define DEV(q)                  ((int)(((q).path >> 8) & 0xff))
#define TYPE(q)                 ((int)((q).path & 0xff))
#define QID(d, t)               ((((d) & 0xff) << 8) | (t))

static int
cegen(Chan*c, char*, Dirtab*, int, int i, Dir*dp)
{
        Qid qid;

        switch(TYPE(c->qid)){
        case Qdir:
                if(i == DEVDOTDOT){
                        mkqid(&qid, QID(0, Qdir), 0, QTDIR);
                        devdir(c, qid, "#C", 0, eve, 0555, dp);
                        return 1;
                }

                if(i == 0){
                        mkqid(&qid, QID(-1, Qctl), 0, QTFILE);
                        devdir(c, qid, "cectl", 0, eve, 0644, dp);
                        return 1;
                }

                if (--i >= Ndsp)
                        return -1;
        
                mkqid(&qid, QID(Qce, i), 0, QTFILE);
                snprint(up->genbuf, sizeof(up->genbuf), "ce%d", i);
                devdir(c, qid, up->genbuf, 0, eve, 0644, dp);
                return 1;

        default:
                return -1;
        }
}

static Walkqid *
cewalk(Chan*c, Chan*nc, char**name, int nname)
{
        return devwalk(c, nc, name, nname, 0, 0, cegen);
}

static int
cestat(Chan*c, uchar*db, int n)
{
        return devstat(c, db, n, 0, 0, cegen);
}

static Chan*
ceopen(Chan*c, int omode)
{
        c->mode = openmode(omode);
        c->flag |= COPEN;
        c->offset = 0;
        return c;
}

static void
ceclose(Chan*)
{}

static long
ceread(Chan*c, void*a, long n, vlong)
{
        switch(TYPE(c->qid)){
        case Qdir:
                return devdirread(c, a, n, 0, 0, cegen);
        
        default:
                error("unsupported operation");
        }
        return 0;
}

static long
cewrite(Chan*, void*, long, vlong)
{
        return 0;
}

Dev cedevtab = {
        'C',
        "channel element",

        devreset,
        ceinit,
        devshutdown,
        ceattach,
        cewalk,
        cestat,
        ceopen,
        devcreate,
        ceclose,
        ceread,
        devbread,
        cewrite,
        devbwrite,
        devremove,
        devwstat,
        devpower,
};