shithub: riscv

ref: 3cc97ac108a3a2889efedfccef6a904baf8ed4e0
dir: /sys/src/9/kw/devarch.c/

#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "../port/error.h"
#include "io.h"

#include "../ip/ip.h"

enum {
	Qdir = 0,
	Qbase,

	Qmax = 16,
};

typedef long Rdwrfn(Chan*, void*, long, vlong);

static Rdwrfn *readfn[Qmax];
static Rdwrfn *writefn[Qmax];

static Dirtab archdir[Qmax] = {
	".",		{ Qdir, 0, QTDIR },	0,	0555,
};

Lock archwlock;	/* the lock is only for changing archdir */
int narchdir = Qbase;

/*
 * Add a file to the #P listing.  Once added, you can't delete it.
 * You can't add a file with the same name as one already there,
 * and you get a pointer to the Dirtab entry so you can do things
 * like change the Qid version.  Changing the Qid path is disallowed.
 */
Dirtab*
addarchfile(char *name, int perm, Rdwrfn *rdfn, Rdwrfn *wrfn)
{
	int i;
	Dirtab d;
	Dirtab *dp;

	memset(&d, 0, sizeof d);
	strcpy(d.name, name);
	d.perm = perm;

	lock(&archwlock);
	if(narchdir >= Qmax){
		unlock(&archwlock);
		return nil;
	}

	for(i=0; i<narchdir; i++)
		if(strcmp(archdir[i].name, name) == 0){
			unlock(&archwlock);
			return nil;
		}

	d.qid.path = narchdir;
	archdir[narchdir] = d;
	readfn[narchdir] = rdfn;
	writefn[narchdir] = wrfn;
	dp = &archdir[narchdir++];
	unlock(&archwlock);

	return dp;
}

static Chan*
archattach(char* spec)
{
	return devattach('P', spec);
}

Walkqid*
archwalk(Chan* c, Chan *nc, char** name, int nname)
{
	return devwalk(c, nc, name, nname, archdir, narchdir, devgen);
}

static int
archstat(Chan* c, uchar* dp, int n)
{
	return devstat(c, dp, n, archdir, narchdir, devgen);
}

static Chan*
archopen(Chan* c, int omode)
{
	return devopen(c, omode, archdir, narchdir, devgen);
}

static void
archclose(Chan*)
{
}

static long
archread(Chan *c, void *a, long n, vlong offset)
{
	Rdwrfn *fn;

	switch((ulong)c->qid.path){
	case Qdir:
		return devdirread(c, a, n, archdir, narchdir, devgen);

	default:
		if(c->qid.path < narchdir && (fn = readfn[c->qid.path]))
			return fn(c, a, n, offset);
		error(Eperm);
		break;
	}

	return 0;
}

static long
archwrite(Chan *c, void *a, long n, vlong offset)
{
	Rdwrfn *fn;

	if(c->qid.path < narchdir && (fn = writefn[c->qid.path]))
		return fn(c, a, n, offset);
	error(Eperm);

	return 0;
}

void archinit(void);

Dev archdevtab = {
	'P',
	"arch",

	devreset,
	archinit,
	devshutdown,
	archattach,
	archwalk,
	archstat,
	archopen,
	devcreate,
	archclose,
	archread,
	devbread,
	archwrite,
	devbwrite,
	devremove,
	devwstat,
};

/* convert AddrDevid register to a string in buf and return buf */
char *
cputype2name(char *buf, int size)
{
	ulong id, archid, rev;
	char *manu, *arch, *socrev;
	char unk[32], socnm[32], revname[32];
	Pciex *pci;

	m->cputype = *(ulong *)soc.devid;
#ifdef OLD
	switch(m->cputype & 3) {
	case 0:
		socnm = "88F6[12]80";
		break;
	case 1:
		socnm = "88F619[02]";
		break;
	case 2:
		socnm = "88F6281";
		break;
	default:
		socnm = "unknown";
		break;
	}
#endif
	/* strange way to get this information, but it's what u-boot does */
	pci = (Pciex *)soc.pci;
	snprint(socnm, sizeof socnm, "88F%ux", pci->devid);
	/* stash rev for benefit of later usb initialisation */
	m->socrev = rev = pci->revid & MASK(4);

	id = cpidget();
	if ((id >> 24) == 0x56 && pci->venid == 0x11ab)
		manu = "Marvell";
	else
		manu = "unknown";
	archid = (id >> 16) & MASK(4);
	switch (archid) {
	case 5:
		arch = "v5te";
		break;
	default:
		snprint(unk, sizeof unk, "unknown (%ld)", archid);
		arch = unk;
		break;
	}
	if (pci->devid != 0x6281)
		socrev = "unknown";
	else
		switch (rev) {
		case Socrevz0:
			socrev = "Z0";
			break;
		case Socreva0:
			socrev = "A0";
			break;
		case Socreva1:
			socrev = "A1";
			break;
		default:
			snprint(revname, sizeof revname, "unknown rev (%ld)",
				rev);
			socrev = revname;
			break;
		}
	seprint(buf, buf + size,
		"%s %s %s; arm926ej-s arch %s rev %ld.%ld part %lux",
		manu, socnm, socrev, arch, (id >> 20) & MASK(4),
		id & MASK(4), (id >> 4) & MASK(12));
	return buf;
}

static long
cputyperead(Chan*, void *a, long n, vlong offset)
{
	char name[64], str[128];

	cputype2name(name, sizeof name);
	snprint(str, sizeof str, "ARM %s %llud\n", name, m->cpuhz / 1000000);
	return readstr(offset, a, n, str);
}

static long
tbread(Chan*, void *a, long n, vlong offset)
{
	char str[16];
	uvlong tb;

	cycles(&tb);

	snprint(str, sizeof(str), "%16.16llux", tb);
	return readstr(offset, a, n, str);
}

static long
nsread(Chan*, void *a, long n, vlong offset)
{
	char str[16];
	uvlong tb;

	cycles(&tb);

	snprint(str, sizeof(str), "%16.16llux", (tb/700)* 1000);
	return readstr(offset, a, n, str);
}

void
archinit(void)
{
	addarchfile("cputype", 0444, cputyperead, nil);
	addarchfile("timebase",0444, tbread, nil);
//	addarchfile("nsec", 0444, nsread, nil);
}