ref: 0afd20e4c409ea8b05916654783150c87dfa0c33
dir: /sys/src/9/teg2/dat.h/
/*
* Time.
*
* HZ should divide 1000 evenly, ideally.
* 100, 125, 200, 250 and 333 are okay.
*/
#define HZ 100 /* clock frequency */
#define MS2HZ (1000/HZ) /* millisec per clock tick */
#define TK2SEC(t) ((t)/HZ) /* ticks to seconds */
enum {
Mhz = 1000 * 1000,
Dogsectimeout = 4, /* must be ≤ 34 s. to fit in a ulong */
};
/*
* More accurate time
*/
#define MS2TMR(t) ((ulong)(((uvlong)(t) * m->cpuhz)/1000))
#define US2TMR(t) ((ulong)(((uvlong)(t) * m->cpuhz)/1000000))
#define CONSOLE 0
typedef struct Conf Conf;
typedef struct Confmem Confmem;
typedef struct FPsave FPsave;
typedef struct PFPU PFPU;
typedef struct ISAConf ISAConf;
typedef struct Isolated Isolated;
typedef struct Label Label;
typedef struct Lock Lock;
typedef struct Lowmemcache Lowmemcache;
typedef struct Memcache Memcache;
typedef struct MMMU MMMU;
typedef struct Mach Mach;
typedef u32int Mreg; /* Msr - bloody UART */
typedef struct Page Page;
typedef struct Pcisiz Pcisiz;
typedef struct Pcidev Pcidev;
typedef struct PhysUart PhysUart;
typedef struct PMMU PMMU;
typedef struct Proc Proc;
typedef u32int PTE;
typedef struct Soc Soc;
typedef struct Uart Uart;
typedef struct Ureg Ureg;
typedef uvlong Tval;
#pragma incomplete Pcidev
#pragma incomplete Ureg
#define MAXSYSARG 5 /* for mount(fd, mpt, flag, arg, srv) */
/*
* parameters for sysproc.c
*/
#define AOUT_MAGIC (E_MAGIC)
struct Lock
{
ulong key;
u32int sr;
uintptr pc;
Proc* p;
Mach* m;
int isilock;
};
struct Label
{
uintptr sp;
uintptr pc;
};
/*
* emulated or vfp3 floating point
*/
enum {
Maxfpregs = 32, /* could be 16 or 32, see Mach.fpnregs */
Nfpctlregs = 16,
};
struct FPsave
{
ulong status;
ulong control;
/*
* vfp3 with ieee fp regs; uvlong is sufficient for hardware but
* each must be able to hold an Internal from fpi.h for sw emulation.
*/
ulong regs[Maxfpregs][3];
int fpstate;
uintptr pc; /* of failed fp instr. */
};
struct PFPU
{
int fpstate;
FPsave fpsave[1];
};
enum
{
FPinit,
FPactive,
FPinactive,
FPemu,
/* bit or'd with the state */
FPillegal= 0x100,
};
struct Confmem
{
uintptr base;
ulong npage;
uintptr limit;
uintptr kbase;
uintptr klimit;
};
struct Conf
{
ulong nmach; /* processors */
ulong nproc; /* processes */
Confmem mem[1]; /* physical memory */
ulong npage; /* total physical pages of memory */
ulong upages; /* user page pool */
ulong copymode; /* 0 is copy on write, 1 is copy on reference */
ulong ialloc; /* max interrupt time allocation in bytes */
ulong pipeqsize; /* size in bytes of pipe queues */
ulong nimage; /* number of page cache image headers */
ulong nswap; /* number of swap pages */
int nswppo; /* max # of pageouts per segment pass */
ulong hz; /* processor cycle freq */
ulong mhz;
int monitor; /* flag */
};
/*
* MMU stuff in Mach.
*/
struct MMMU
{
PTE* mmul1; /* l1 for this processor */
int mmul1lo;
int mmul1hi;
int mmupid;
};
/*
* MMU stuff in proc
*/
#define NCOLOR 1 /* 1 level cache, don't worry about VCE's */
struct PMMU
{
Page* mmul2;
Page* mmul2cache; /* free mmu pages */
};
#include "../port/portdat.h"
struct Mach
{
int machno; /* physical id of processor */
uintptr splpc; /* pc of last caller to splhi */
Proc* proc; /* current process on this processor */
MMMU;
/* end of offsets known to asm */
PMach;
uvlong fastclock; /* last sampled value */
int inclockintr;
int inidlehands;
int probing; /* probeaddr() state */
int trapped;
Lock probelock;
int cputype;
ulong delayloop;
int cpumhz;
uvlong cpuhz; /* speed of cpu */
/* vfp3 fpu */
int havefp;
int havefpvalid;
int fpon;
int fpconfiged;
int fpnregs;
ulong fpscr; /* sw copy */
int fppid; /* pid of last fault */
uintptr fppc; /* addr of last fault */
int fpcnt; /* how many consecutive at that addr */
/* save areas for exceptions, hold R0-R4 */
u32int sfiq[5];
u32int sirq[5];
u32int sund[5];
u32int sabt[5];
u32int smon[5]; /* probably not needed */
u32int ssys[5];
uintptr stack[1];
};
/*
* Fake kmap.
*/
typedef void KMap;
#define VA(k) ((uintptr)(k))
#define kmap(p) (KMap*)((p)->pa|kseg0)
#define kunmap(k)
struct
{
Lock;
char machs[MAXMACH]; /* active CPUs */
int wfi; /* bitmap of CPUs in WFI state */
int stopped; /* bitmap of CPUs stopped */
int exiting; /* shutdown */
}active;
extern register Mach* m; /* R10 */
extern register Proc* up; /* R9 */
/* an object guaranteed to be in its own cache line */
typedef uchar Cacheline[CACHELINESZ];
struct Isolated {
Cacheline c0;
ulong word;
Cacheline c1;
};
extern Memcache cachel[]; /* arm arch v7 supports 1-7 */
extern ulong intrcount[MAXMACH];
extern int irqtooearly;
extern uintptr kseg0;
extern Isolated l1ptstable;
extern uchar *l2pages;
extern Mach* machaddr[MAXMACH];
extern ulong memsize;
extern int navailcpus;
extern int normalprint;
/*
* a parsed plan9.ini line
*/
#define NISAOPT 8
struct ISAConf {
char *type;
ulong port;
int irq;
ulong dma;
ulong mem;
ulong size;
ulong freq;
int nopt;
char *opt[NISAOPT];
};
#define MACHP(n) machaddr[n]
/*
* Horrid. But the alternative is 'defined'.
*/
#ifdef _DBGC_
#define DBGFLG (dbgflg[_DBGC_])
#else
#define DBGFLG (0)
#endif /* _DBGC_ */
int vflag;
extern char dbgflg[256];
#define dbgprint print /* for now */
/*
* hardware info about a device
*/
typedef struct {
ulong port;
int size;
} Devport;
struct DevConf
{
ulong intnum; /* interrupt number */
char *type; /* card type, malloced */
int nports; /* Number of ports */
Devport *ports; /* The ports themselves */
};
/* characteristics of a given arm cache level */
struct Memcache {
uint waysh; /* shifts for set/way register */
uint setsh;
uint log2linelen;
uint level; /* 1 is nearest processor, 2 further away */
uint type;
uint external; /* flag */
uint l1ip; /* l1 I policy */
uint nways; /* associativity */
uint nsets;
uint linelen; /* bytes per cache line */
uint setsways;
};
enum Cachetype {
Nocache,
Ionly,
Donly,
Splitid,
Unified,
};
enum {
Intcache,
Extcache,
};
/*
* characteristics of cache level, kept at low, fixed address (CACHECONF).
* all offsets are known to cache.v7.s.
*/
struct Lowmemcache {
uint l1waysh; /* shifts for set/way register */
uint l1setsh;
uint l2waysh;
uint l2setsh;
};
/*
* cache capabilities. write-back vs write-through is controlled
* by the Buffered bit in PTEs.
*
* see cache.v7.s and Memcache in dat.h
*/
enum {
Cawt = 1 << 31,
Cawb = 1 << 30,
Cara = 1 << 29,
Cawa = 1 << 28,
};
/* non-architectural L2 cache */
typedef struct Cacheimpl Cacheimpl;
struct Cacheimpl {
void (*info)(Memcache *);
void (*on)(void);
void (*off)(void);
void (*inv)(void);
void (*wb)(void);
void (*wbinv)(void);
void (*invse)(void *, int);
void (*wbse)(void *, int);
void (*wbinvse)(void *, int);
};
/* extern */ Cacheimpl *l2cache, *allcache, *nocache, *l1cache;
enum Dmamode {
Const,
Postincr,
Index,
Index2,
};
/* pmu = power management unit */
enum Irqs {
/*
* 1st 32 gic irqs reserved for cpu; private interrupts.
* 0—15 are software-generated by other cpus;
* 16—31 are private peripheral intrs.
*/
Cpu0irq = 0,
Cpu1irq,
/* ... */
Cpu15irq = 15,
Glbtmrirq = 27,
Loctmrirq = 29,
Wdtmrirq = 30,
/* shared interrupts */
Ctlr0base = (1+0)*32, /* primary ctlr */
Tn0irq = Ctlr0base + 0, /* tegra timers */
Tn1irq = Ctlr0base + 1,
Rtcirq = Ctlr0base + 2,
Ctlr1base = (1+1)*32, /* secondary ctlr */
Uartirq = Ctlr1base + 4,
Tn2irq = Ctlr1base + 9, /* tegra timers */
Tn3irq = Ctlr1base + 10,
/* +24 is cpu0_pmu_intr, +25 is cpu1_pum_intr */
Ctlr2base = (1+2)*32, /* ternary ctlr */
Extpmuirq = Ctlr2base + 22,
Ctlr3base = (1+3)*32, /* quad ctlr */
Pcieirq = Ctlr3base + 2,
};
struct Soc { /* addr's of SoC controllers */
uintptr clkrst;
uintptr power;
uintptr exceptvec;
uintptr sema;
uintptr l2cache;
uintptr flow;
/* private memory region */
uintptr scu;
uintptr intr; /* `cpu interface' */
/* private-peripheral-interrupt cortex-a clocks */
uintptr glbtmr;
uintptr loctmr;
uintptr intrdist;
uintptr uart[5];
/* shared-peripheral-interrupt tegra2 clocks */
uintptr rtc; /* real-time clock */
uintptr tmr[4];
uintptr µs;
uintptr pci;
uintptr ether;
uintptr ehci;
uintptr ide;
uintptr nand;
uintptr nor;
uintptr spi[4];
uintptr twsi;
uintptr mmc[4];
uintptr gpio[7];
} soc;
extern Soc soc;