ref: 9e1b4cb6b3a24e6fab6512280620fc2b8c5a321f
dir: /sys/src/9/ppc/m8260.c/
/*
* 8260 specific stuff:
* Interrupt handling
*/
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "io.h"
#include "fns.h"
#include "m8260.h"
enum {
Pin4 = BIT(4),
};
static union {
struct {
ulong hi;
ulong lo;
};
uvlong val;
} ticks;
struct {
ulong hi;
ulong lo;
} vec2mask[64] = {
[0] = {0, 0 }, /* Error, No interrupt */
[1] = {0, BIT(16) }, /* I2C */
[2] = {0, BIT(17) }, /* SPI */
[3] = {0, BIT(18) }, /* Risc Timers */
[4] = {0, BIT(19) }, /* SMC1 */
[5] = {0, BIT(20) }, /* SMC2 */
[6] = {0, BIT(21) }, /* IDMA1 */
[7] = {0, BIT(22) }, /* IDMA2 */
[8] = {0, BIT(23) }, /* IDMA3 */
[9] = {0, BIT(24) }, /* IDMA4 */
[10] = {0, BIT(25) }, /* SDMA */
[11] = {0, 0 }, /* Reserved */
[12] = {0, BIT(27) }, /* Timer1 */
[13] = {0, BIT(28) }, /* Timer2 */
[14] = {0, BIT(29) }, /* Timer3 */
[15] = {0, BIT(30) }, /* Timer4 */
[16] = {BIT(29), 0 }, /* TMCNT */
[17] = {BIT(30), 0 }, /* PIT */
[18] = {0, 0 }, /* Reserved */
[19] = {BIT(17), 0 }, /* IRQ1 */
[20] = {BIT(18), 0 }, /* IRQ2 */
[21] = {BIT(19), 0 }, /* IRQ3 */
[22] = {BIT(20), 0 }, /* IRQ4 */
[23] = {BIT(21), 0 }, /* IRQ5 */
[24] = {BIT(22), 0 }, /* IRQ6 */
[25] = {BIT(23), 0 }, /* IRQ7 */
[26] = {0, 0 }, /* Reserved */
[27] = {0, 0 }, /* Reserved */
[28] = {0, 0 }, /* Reserved */
[29] = {0, 0 }, /* Reserved */
[30] = {0, 0 }, /* Reserved */
[31] = {0, 0 }, /* Reserved */
[32] = {0, BIT(0) }, /* FCC1 */
[33] = {0, BIT(1) }, /* FCC2 */
[34] = {0, BIT(2) }, /* FCC3 */
[35] = {0, 0 }, /* Reserved */
[36] = {0, BIT(4) }, /* MCC1 */
[37] = {0, BIT(5) }, /* MCC2 */
[38] = {0, 0 }, /* Reserved */
[39] = {0, 0 }, /* Reserved */
[40] = {0, BIT(8) }, /* SCC1 */
[41] = {0, BIT(9) }, /* SCC2 */
[42] = {0, BIT(10) }, /* SCC3 */
[43] = {0, BIT(11) }, /* SCC4 */
[44] = {0, 0 }, /* Reserved */
[45] = {0, 0 }, /* Reserved */
[46] = {0, 0 }, /* Reserved */
[47] = {0, 0 }, /* Reserved */
[48] = {BIT(15), 0 }, /* PC15 */
[49] = {BIT(14), 0 }, /* PC14 */
[50] = {BIT(13), 0 }, /* PC13 */
[51] = {BIT(12), 0 }, /* PC12 */
[52] = {BIT(11), 0 }, /* PC11 */
[53] = {BIT(10), 0 }, /* PC10 */
[54] = {BIT(9), 0 }, /* PC9 */
[55] = {BIT(8), 0 }, /* PC8 */
[56] = {BIT(7), 0 }, /* PC7 */
[57] = {BIT(6), 0 }, /* PC6 */
[58] = {BIT(5), 0 }, /* PC5 */
[59] = {BIT(4), 0 }, /* PC4 */
[60] = {BIT(3), 0 }, /* PC3 */
[61] = {BIT(2), 0 }, /* PC2 */
[62] = {BIT(1), 0 }, /* PC1 */
[63] = {BIT(0), 0 }, /* PC0 */
};
/* Blast memory layout:
* CS0: FE000000 -> FFFFFFFF (Flash)
* CS1: FC000000 -> FCFFFFFF (DSP hpi)
* CS2: 00000000 -> 03FFFFFF (60x sdram)
* CS3: 04000000 -> 04FFFFFF (FPGA)
* CS4: 05000000 -> 06FFFFFF (local bus sdram)
* CS5: 07000000 -> 0700FFFF (eeprom - not populated)
* CS6: E0000000 -> E0FFFFFF (FPGA - 64bits)
*
* Main Board memory layout:
* CS0: FE000000 -> FEFFFFFF (16 M FLASH)
* CS1: FC000000 -> FCFFFFFF (16 M DSP1)
* CS2: 00000000 -> 03FFFFFF (64 M SDRAM)
* CS3: 04000000 -> 04FFFFFF (16M DSP2)
* CS4: 05000000 -> 06FFFFFF (32 M Local SDRAM)
* CS5: 07000000 -> 0700FFFF (eeprom - not populated)
* CS6: unused
* CS7: E0000000 -> E0FFFFFF (16 M FPGA)
*/
IMM* iomem = (IMM*)IOMEM;
static Lock cpmlock;
void
machinit(void)
{
ulong scmr;
int pllmf;
extern char* plan9inistr;
memset(m, 0, sizeof(*m));
m->cputype = getpvr()>>16; /* pvr = 0x00810101 for the 8260 */
m->imap = (Imap*)INTMEM;
m->loopconst = 1096;
/* Make sure Ethernet is disabled (boot code may have buffers allocated anywhere in memory) */
iomem->fcc[0].gfmr &= ~(BIT(27)|BIT(26));
iomem->fcc[1].gfmr &= ~(BIT(27)|BIT(26));
iomem->fcc[2].gfmr &= ~(BIT(27)|BIT(26));
/* Flashed CS configuration is wrong for DSP2. It's set to 64 bits, should be 16 */
iomem->bank[3].br = 0x04001001; /* Set 16-bit port */
/*
* FPGA is capable of doing 64-bit transfers. To use these, set br to 0xe0000001.
* Currently we use 32-bit transfers, because the 8260 does not easily do 64-bit operations.
*/
iomem->bank[6].br = 0xe0001801;
iomem->bank[6].or = 0xff000830; /* Was 0xff000816 */
/*
* All systems with rev. A.1 (0K26N) silicon had serious problems when doing
* DMA transfers with data cache enabled (usually this shows when using
* one of the FCC's with some traffic on the ethernet). Allocating FCC buffer
* descriptors in main memory instead of DP ram solves this problem.
*/
/* Guess at clocks based upon the PLL configuration from the
* power-on reset.
*/
scmr = iomem->scmr;
/* The EST8260 is typically run using either 33 or 66 MHz
* external clock. The configuration byte in the Flash will
* tell us which is configured. The blast appears to be slightly
* overclocked at 72 MHz (if set to 66 MHz, the uart runs too fast)
*/
m->clkin = CLKIN;
pllmf = scmr & 0xfff;
/* This is arithmetic from the 8260 manual, section 9.4.1. */
/* Collect the bits from the scmr.
*/
m->vco_out = m->clkin * (pllmf + 1);
if (scmr & BIT(19)) /* plldf (division factor is 1 or 2) */
m->vco_out >>= 1;
m->cpmhz = m->vco_out >> 1; /* cpm hz is half of vco_out */
m->brghz = m->vco_out >> (2 * ((iomem->sccr & 0x3) + 1));
m->bushz = m->vco_out / (((scmr & 0x00f00000) >> 20) + 1);
/* Serial init sets BRG clock....I don't know how to compute
* core clock from core configuration, but I think I know the
* mapping....
*/
switch(scmr >> (31-7)){
case 0x0a:
m->cpuhz = m->clkin * 2;
break;
case 0x0b:
m->cpuhz = (m->clkin >> 1) * 5;
break;
default:
case 0x0d:
m->cpuhz = m->clkin * 3;
break;
case 0x14:
m->cpuhz = (m->clkin >> 1) * 7;
break;
case 0x1c:
m->cpuhz = m->clkin * 4;
break;
}
m->cyclefreq = m->bushz / 4;
/* Expect:
intfreq 133 m->cpuhz
busfreq 33 m->bushz
cpmfreq 99 m->cpmhz
brgfreq 49.5 m->brghz
vco 198
*/
active.machs[0] = 1;
active.exiting = 0;
putmsr(getmsr() | MSR_ME);
/*
* turn on data cache before instruction cache;
* for some reason which I don't understand,
* you can't turn on both caches at once
*/
icacheenb();
dcacheenb();
kfpinit();
/* Plan9.ini location in flash is FLASHMEM+PLAN9INI
* if PLAN9INI == ~0, it's not stored in flash or there is no flash
* if *cp == 0xff, flash memory is not initialized
*/
if (PLAN9INI == ~0 || *(plan9inistr = (char*)(FLASHMEM+PLAN9INI)) == 0xff){
/* No plan9.ini in flash */
plan9inistr =
"console=0\n"
"ether0=type=fcc port=0 ea=00601d051dd8\n"
"flash0=mem=0xfe000000\n"
"fs=135.104.9.42\n"
"auth=135.104.9.7\n"
"authdom=cs.bell-labs.com\n"
"sys=blast\n"
"ntp=135.104.9.52\n";
}
}
void
fpgareset(void)
{
print("fpga reset\n");
ioplock();
iomem->port[1].pdat &= ~Pin4; /* force reset signal to 0 */
delay(100);
iomem->port[1].pdat |= Pin4; /* force reset signal back to one */
iopunlock();
}
void
hwintrinit(void)
{
iomem->sicr = 2 << 8;
/* Write ones into most bits of the interrupt pending registers to clear interrupts */
iomem->sipnr_h = ~7;
iomem->sipnr_h = ~1;
/* Clear the interrupt masks, thereby disabling all interrupts */
iomem->simr_h = 0;
iomem->simr_l = 0;
iomem->sypcr &= ~2; /* cause a machine check interrupt on memory timeout */
/* Initialize fpga reset pin */
iomem->port[1].pdir |= Pin4; /* 1 is an output */
iomem->port[1].ppar &= ~Pin4;
iomem->port[1].pdat |= Pin4; /* force reset signal back to one */
}
int
vectorenable(Vctl *v)
{
ulong hi, lo;
if (v->irq & ~0x3f){
print("m8260enable: interrupt vector %d out of range\n", v->irq);
return -1;
}
hi = vec2mask[v->irq].hi;
lo = vec2mask[v->irq].lo;
if (hi == 0 && lo == 0){
print("m8260enable: nonexistent vector %d\n", v->irq);
return -1;
}
ioplock();
/* Clear the interrupt before enabling */
iomem->sipnr_h |= hi;
iomem->sipnr_l |= lo;
/* Enable */
iomem->simr_h |= hi;
iomem->simr_l |= lo;
iopunlock();
return v->irq;
}
void
vectordisable(Vctl *v)
{
ulong hi, lo;
if (v->irq & ~0x3f){
print("m8260disable: interrupt vector %d out of range\n", v->irq);
return;
}
hi = vec2mask[v->irq].hi;
lo = vec2mask[v->irq].lo;
if (hi == 0 && lo == 0){
print("m8260disable: nonexistent vector %d\n", v->irq);
return;
}
ioplock();
iomem->simr_h &= ~hi;
iomem->simr_l &= ~lo;
iopunlock();
}
int
intvec(void)
{
return iomem->sivec >> 26;
}
void
intend(int vno)
{
/* Clear interrupt */
ioplock();
iomem->sipnr_h |= vec2mask[vno].hi;
iomem->sipnr_l |= vec2mask[vno].lo;
iopunlock();
}
int
m8260eoi(int)
{
return 0;
}
int
m8260isr(int)
{
return 0;
}
void
flashprogpower(int)
{
}
enum {
TgcrCas = 0x80,
TgcrGm = 0x08,
TgcrStp = 0x2, /* There are two of these, timer-2 bits are bits << 4 */
TgcrRst = 0x1,
TmrIclkCasc = 0x00<<1,
TmrIclkIntclock = 0x01<<1,
TmrIclkIntclock16 = 0x02<<1,
TmrIclkTin = 0x03<<1,
TmrCERising = 0x1 << 6,
TmrCEFalling = 0x2 << 6,
TmrCEAny = 0x3 << 6,
TmrFrr = SBIT(12),
TmrOri = SBIT(11),
TerRef = SBIT(14),
TerCap = SBIT(15),
};
uvlong
fastticks(uvlong *hz)
{
ulong count;
static Lock fasttickslock;
if (hz)
*hz = m->clkin>>1;
ilock(&fasttickslock);
count = iomem->tcnl1;
if (count < ticks.lo)
ticks.hi += 1;
ticks.lo = count;
iunlock(&fasttickslock);
return ticks.val;
}
void
timerset(uvlong next)
{
long offset;
uvlong now;
static int cnt;
now = fastticks(nil);
offset = next - now;
if (offset < 2500)
next = now + 2500; /* 10000 instructions */
else if (offset > m->clkin / HZ){
print("too far in the future: offset %llux, now %llux\n", next, now);
next = now + m->clkin / HZ;
}
iomem->trrl1 = next;
}
void
m8260timerintr(Ureg *u, void*)
{
iomem->ter2 |= TerRef | TerCap; /* Clear interrupt */
timerintr(u, 0);
}
void
timerinit(void)
{
iomem->tgcr1 = TgcrCas | TgcrGm; /* cascade timers 1 & 2, normal gate mode */
iomem->tcnl1 = 0;
iomem->trrl1 = m->clkin / HZ; /* first capture in 1/HZ seconds */
iomem->tmr1 = TmrIclkCasc;
iomem->tmr2 = TmrIclkIntclock | TmrOri;
intrenable(13, m8260timerintr, nil, "timer"); /* Timer 2 interrupt is on 13 */
iomem->tgcr1 |= TgcrRst << 4;
}
static void
addseg(char *name, ulong start, ulong length)
{
Physseg segbuf;
memset(&segbuf, 0, sizeof(segbuf));
segbuf.attr = SG_PHYSICAL | SG_DEVICE | SG_NOEXEC;
kstrdup(&segbuf.name, name);
segbuf.pa = start;
segbuf.size = length;
if (addphysseg(&segbuf) == nil) {
print("addphysseg: %s\n", name);
return;
}
}
void
sharedseginit(void)
{
int i, j;
ulong base, size;
char name[16], *a, *b, *s;
static char *segnames[] = {
"fpga",
"dsp",
};
for (j = 0; j < nelem(segnames); j++){
for (i = 0; i < 8; i++){
snprint(name, sizeof name, "%s%d", segnames[j], i);
if ((a = getconf(name)) == nil)
continue;
if ((b = strstr(a, "mem=")) == nil){
print("blastseginit: %s: no base\n", name);
continue;
}
b += 4;
base = strtoul(b, nil, 0);
if (base == 0){
print("blastseginit: %s: bad base: %s\n", name, b);
continue;
}
if ((s = strstr(a, "size=")) == nil){
print("blastseginit: %s: no size\n", name);
continue;
}
s += 5;
size = strtoul(s, nil, 0);
if (size == 0){
print("blastseginit: %s: bad size: %s\n", name, s);
continue;
}
addseg(name, base, size);
}
}
}
void
cpmop(int op, int dev, int mcn)
{
ioplock();
eieio();
while(iomem->cpcr & 0x10000)
eieio();
iomem->cpcr = dev<<(31-10) | mcn<<(31-25) | op | 0x10000;
eieio();
while(iomem->cpcr & 0x10000)
eieio();
iopunlock();
}
/*
* connect SCCx clocks in NSMI mode (x=1 for USB)
*/
void
sccnmsi(int x, int rcs, int tcs)
{
ulong v;
int sh;
sh = (x-1)*8; /* each SCCx field in sicr is 8 bits */
v = (((rcs&7)<<3) | (tcs&7)) << sh;
iomem->sicr = (iomem->sicr & ~(0xFF<<sh)) | v;
}
/*
* lock the shared IO memory and return a reference to it
*/
void
ioplock(void)
{
ilock(&cpmlock);
}
/*
* release the lock on the shared IO memory
*/
void
iopunlock(void)
{
eieio();
iunlock(&cpmlock);
}
BD*
bdalloc(int n)
{
static BD *palloc = ((Imap*)INTMEM)->bd;
BD *p;
p = palloc;
if (palloc > ((Imap*)INTMEM)->bd + nelem(((Imap*)INTMEM)->bd)){
print("bdalloc: out of BDs\n");
return nil;
}
palloc += n;
return p;
}
/*
* Initialise receive and transmit buffer rings. Only used for FCC
* Ethernet now.
*
* Ioringinit will allocate the buffer descriptors in normal memory
* and NOT in Dual-Ported Ram, as prescribed by the MPC8260
* PowerQUICC II manual (Section 28.6). When they are allocated
* in DPram and the Dcache is enabled, the processor will hang.
* This has been observed for the FCCs, it may or may not be true
* for SCCs or DMA.
* The SMC Uart buffer descriptors are not allocated here; (1) they
* can ONLY be in DPram and (2) they are not configured as a ring.
*/
int
ioringinit(Ring* r, int nrdre, int ntdre, int bufsize)
{
int i, x;
static uchar *dpmallocaddr;
static uchar *dpmallocend;
if (dpmallocaddr == nil){
dpmallocaddr = m->imap->dpram1;
dpmallocend = dpmallocaddr + sizeof(m->imap->dpram1);
}
/* the ring entries must be aligned on sizeof(BD) boundaries */
r->nrdre = nrdre;
if(r->rdr == nil)
r->rdr = xspanalloc(nrdre*sizeof(BD), 0, 8);
if(r->rdr == nil)
return -1;
if(r->rrb == nil && bufsize){
r->rrb = xspanalloc(nrdre*bufsize, 0, CACHELINESZ);
if(r->rrb == nil)
return -1;
}
x = bufsize ? PADDR(r->rrb) : 0;
for(i = 0; i < nrdre; i++){
r->rdr[i].length = 0;
r->rdr[i].addr = x;
r->rdr[i].status = BDEmpty|BDInt;
x += bufsize;
}
r->rdr[i-1].status |= BDWrap;
r->rdrx = 0;
r->ntdre = ntdre;
if(r->tdr == nil)
r->tdr = xspanalloc(ntdre*sizeof(BD), 0, 8);
if(r->txb == nil)
r->txb = xspanalloc(ntdre*sizeof(Block*), 0, CACHELINESZ);
if(r->tdr == nil || r->txb == nil)
return -1;
for(i = 0; i < ntdre; i++){
r->txb[i] = nil;
r->tdr[i].addr = 0;
r->tdr[i].length = 0;
r->tdr[i].status = 0;
}
r->tdr[i-1].status |= BDWrap;
r->tdrh = 0;
r->tdri = 0;
r->ntq = 0;
return 0;
}
void
trapinit(void)
{
int i;
/*
* set all exceptions to trap
*/
for(i = 0x0; i < 0x2000; i += 0x100)
sethvec(i, trapvec);
setmvec(0x1000, imiss, tlbvec);
setmvec(0x1100, dmiss, tlbvec);
setmvec(0x1200, dmiss, tlbvec);
/* Useful for avoiding assembler miss handling:
sethvec(0x1000, tlbvec);
sethvec(0x1100, tlbvec);
sethvec(0x1200, tlbvec);
/* */
dcflush(KADDR(0), 0x2000);
icflush(KADDR(0), 0x2000);
putmsr(getmsr() & ~MSR_IP);
}
void
reboot(void*, void*, ulong)
{
ulong *p;
int x;
p = (ulong*)0x90000000;
x = splhi();
iomem->sypcr |= 0xc0;
print("iomem->sypcr = 0x%lux\n", iomem->sypcr);
*p = 0;
print("still alive\n");
splx(x);
}