![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kmc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / dev|
Return to kmc.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 ! root 1: /* ! 2: * KMC11 microprocessor driver ! 3: */ ! 4: #include "kmc.h" ! 5: #if NKMC > 0 ! 6: /* this driver supports ONE kmc ONLY */ ! 7: /* it should be modified to support only kmc11b's too */ ! 8: ! 9: /* nonstandard crap */ ! 10: typedef unsigned short ushort; ! 11: #define lobyte(X) (((unsigned char *)&X)[0]) ! 12: #define hibyte(X) (((unsigned char *)&X)[1]) ! 13: ! 14: #include "../h/param.h" ! 15: #include "../h/systm.h" ! 16: #include "../h/kmc.h" ! 17: #include "../h/pte.h" ! 18: #include "../h/map.h" ! 19: #include "../h/buf.h" ! 20: #include "../h/ubareg.h" ! 21: #include "../h/ubavar.h" ! 22: #include "../h/conf.h" ! 23: #include "../h/dir.h" ! 24: #include "../h/user.h" ! 25: ! 26: struct kmc { ! 27: char k_stat; ! 28: char k_type; ! 29: } kmc[NKMC]; ! 30: ! 31: #define KMC11A 1 ! 32: #define KMC11B 2 ! 33: #define KASIZE 1024 ! 34: #define KBSIZE 4096 ! 35: ! 36: #define RUN (1<<7) ! 37: #define MCLR (1<<6) ! 38: #define CWRT (1<<5) ! 39: #define LUB (1<<4) ! 40: #define LUA (1<<3) ! 41: #define ROMO (1<<2) ! 42: #define ROMI (1<<1) ! 43: #define STEP (1<<0) ! 44: ! 45: #define RDYO 0200 ! 46: #define RDYI 020 ! 47: #define RQI 0200 ! 48: #define IEI 01 ! 49: #define IEO 020 ! 50: ! 51: #define STYPE 017 ! 52: #define SRUN 020 ! 53: #define SRINT 040 ! 54: #define SOPEN 0100 ! 55: ! 56: struct device { ! 57: union { ! 58: char b[8]; ! 59: ushort w[4]; ! 60: } un; ! 61: }; ! 62: ! 63: #define bsel0 un.b[0] ! 64: #define bsel1 un.b[1] ! 65: #define bsel2 un.b[2] ! 66: #define bsel3 un.b[3] ! 67: #define bsel4 un.b[4] ! 68: #define bsel5 un.b[5] ! 69: #define bsel6 un.b[6] ! 70: #define bsel7 un.b[7] ! 71: #define sel0 un.w[0] ! 72: #define sel2 un.w[1] ! 73: #define sel4 un.w[2] ! 74: #define sel6 un.w[3] ! 75: ! 76: int kmcwritten; ! 77: int kmcprobe(), kmcattach(), kmcxint(); ! 78: struct uba_device *kmcdinfo[NKMC]; ! 79: unsigned short kmcstd[] = { 0}; ! 80: struct uba_driver kmcdriver = { ! 81: kmcprobe, 0, kmcattach, 0, kmcstd, "kmc", kmcdinfo ! 82: }; ! 83: ! 84: int (*kdirint)(); ! 85: int (*kdixint)(); ! 86: ! 87: kmcprobe(reg) ! 88: caddr_t reg; ! 89: { register int br, cvec; /* don't touch */ ! 90: register struct device *kp = (struct device *)reg; ! 91: register s; ! 92: ! 93: #ifdef lint ! 94: br = 0; cvec = br; br = cvec; ! 95: #endif ! 96: s = spl7(); ! 97: kp->bsel1 = MCLR; ! 98: splx(s); ! 99: kp->bsel1 = ROMI; ! 100: kp->sel4 = 0200; /* bus request */ ! 101: kp->sel6 = 0121111; /* mov csr4,obr */ ! 102: kp->bsel1 = ROMI|STEP; ! 103: DELAY(50); ! 104: kp->bsel1 = 0; ! 105: return(1); ! 106: } ! 107: ! 108: kmcattach(ui) ! 109: register struct uba_device *ui; ! 110: {} ! 111: ! 112: kmcopen(dev, flag) ! 113: dev_t dev; ! 114: { register struct device *kp; ! 115: register struct kmc *tp; ! 116: register sav; ! 117: ! 118: dev = minor(dev); ! 119: if (dev>=NKMC || (tp = &kmc[dev])->k_stat&SOPEN) { ! 120: u.u_error = ENXIO; ! 121: return; ! 122: } ! 123: kmcwritten = 0; ! 124: tp->k_stat |= SOPEN; ! 125: if (tp->k_type==0) { ! 126: kp = ((struct device *)kmcdinfo[dev]->ui_addr); ! 127: kp->bsel1 = ROMO; ! 128: kp->sel4 = 0; ! 129: sav = kp->sel6; ! 130: kp->sel6 = ~sav; ! 131: if (kp->sel6 != sav) { ! 132: tp->k_type = KMC11B; ! 133: kp->sel6 = sav; ! 134: } else ! 135: tp->k_type = KMC11A; ! 136: kp->bsel1 = 0; ! 137: } ! 138: } ! 139: ! 140: kmcclose(dev) ! 141: dev_t dev; ! 142: { ! 143: dev = minor(dev); ! 144: if(dev >= NKMC) ! 145: return; ! 146: kmc[dev].k_stat &= ~SOPEN; ! 147: if (kmcwritten) ! 148: kdireload(); ! 149: } ! 150: ! 151: kmcread(dev) ! 152: dev_t dev; ! 153: { register struct device *kp; ! 154: register ad; ! 155: int dsize; ! 156: ushort sav; ! 157: ! 158: dev = minor(dev); ! 159: if(dev >= NKMC) { ! 160: u.u_error = ENXIO; ! 161: return; ! 162: } ! 163: if (kmc[dev].k_stat&SRUN) ! 164: return; ! 165: dsize = (kmc[dev].k_type==KMC11A)?KASIZE:KBSIZE; ! 166: kp = ((struct device *)kmcdinfo[dev]->ui_addr); ! 167: kp->bsel1 = 0; ! 168: do { ! 169: ad = u.u_offset; ! 170: if (ad<dsize*2) { ! 171: if (ad&1) { ! 172: u.u_error = ENXIO; ! 173: break; ! 174: } ! 175: ad >>= 1; ! 176: kp->bsel1 = ROMO; ! 177: kp->sel4 = ad; ! 178: passc(kp->bsel6); ! 179: passc(kp->bsel7); ! 180: kp->bsel1 = 0; ! 181: } else if (ad -= dsize*2, ad<dsize) { ! 182: kp->bsel1 = ROMO; ! 183: kp->sel4 = 0; ! 184: sav = kp->sel6; ! 185: kp->bsel1 = ROMI; ! 186: kp->sel6 = 010000|(ad&0377); /* mov ad,mar */ ! 187: kp->bsel1 = ROMI|STEP; ! 188: kp->bsel1 = ROMI; ! 189: kp->sel6 = 04000|((ad>>8)&0377); /* mov %ad,%mar */ ! 190: kp->bsel1 = ROMI|STEP; ! 191: kp->bsel1 = ROMI; ! 192: kp->sel6 = 055222; /* mov mem,csr2|mar++ */ ! 193: kp->bsel1 = ROMI|STEP; ! 194: passc(kp->bsel2); ! 195: kp->bsel1 = ROMI; ! 196: kp->sel6 = sav; ! 197: kp->bsel1 = 0; ! 198: } else ! 199: break; ! 200: } while (u.u_error==0 && u.u_count); ! 201: } ! 202: ! 203: kmcwrite(dev) ! 204: dev_t dev; ! 205: { register struct device *kp; ! 206: register ad; ! 207: int dsize; ! 208: short ins; ! 209: ushort sav; ! 210: ! 211: dev = minor(dev); ! 212: if(dev >= NKMC) { ! 213: u.u_error = ENXIO; ! 214: return; ! 215: } ! 216: if (kmc[dev].k_stat&SRUN) ! 217: return; ! 218: dsize = (kmc[dev].k_type==KMC11A)?KASIZE:KBSIZE; ! 219: kp = ((struct device *)kmcdinfo[dev]->ui_addr); ! 220: kp->bsel1 = 0; ! 221: kmcwritten = 1; ! 222: while (u.u_error==0 && u.u_count) { ! 223: ad = u.u_offset; ! 224: if (ad<dsize*2) { ! 225: if (ad&1) { ! 226: u.u_error = ENXIO; ! 227: break; ! 228: } ! 229: kp->bsel1 = ROMO; ! 230: kp->sel4 = ad>>1; ! 231: lobyte(ins) = cpass(); ! 232: hibyte(ins) = cpass(); ! 233: kp->sel6 = ins; ! 234: kp->bsel1 |= CWRT; ! 235: kp->bsel1 = 0; ! 236: } else if (ad -= dsize*2, ad<dsize) { ! 237: kp->bsel1 = ROMO; ! 238: kp->sel4 = 0; ! 239: sav = kp->sel6; ! 240: kp->bsel1 = ROMI; ! 241: kp->sel6 = 010000|(ad&0377); /* mov ad,mar */ ! 242: kp->bsel1 = ROMI|STEP; ! 243: kp->bsel1 = ROMI; ! 244: kp->sel6 = 04000|((ad>>8)&0377); /* mov %ad,%mar */ ! 245: kp->bsel1 = ROMI|STEP; ! 246: kp->bsel1 = ROMI; ! 247: kp->bsel2 = cpass(); ! 248: kp->sel6 = 0136440; /* mov csr2,mem|mar++ */ ! 249: kp->bsel1 = ROMI|STEP; ! 250: kp->bsel1 = ROMI; ! 251: kp->sel6 = sav; ! 252: kp->bsel1 = 0; ! 253: } else ! 254: break; ! 255: } ! 256: } ! 257: ! 258: kmcioctl(dev, cmd, arg, mode) ! 259: caddr_t arg; ! 260: dev_t dev; ! 261: { register struct device *kp; ! 262: register struct kmc *tp; ! 263: struct kmcntl kk; ! 264: short csr[4]; ! 265: ushort sav; ! 266: ! 267: dev = minor(dev); ! 268: if (cmd != KCSETA) { ! 269: u.u_error = EINVAL; ! 270: return; ! 271: } ! 272: if(dev >= NKMC) { ! 273: u.u_error = ENXIO; ! 274: return; ! 275: } ! 276: if (copyin(arg, &kk, sizeof(kk))) { ! 277: u.u_error = EFAULT; ! 278: return; ! 279: } ! 280: kp = ((struct device *)kmcdinfo[dev]->ui_addr); ! 281: tp = &kmc[dev]; ! 282: switch (kk.kmd) { ! 283: case KMCLR: ! 284: case KRESET: ! 285: spl7(); ! 286: kp->bsel1 = MCLR; ! 287: spl0(); ! 288: case KSTOP: ! 289: tp->k_stat &= ~SRUN; ! 290: kp->bsel1 = 0; ! 291: if (kk.kmd == KRESET) { ! 292: tp->k_stat = 0; ! 293: /* flush here */ ! 294: } ! 295: return; ! 296: case KMS: ! 297: if (tp->k_stat&SRUN) ! 298: break; ! 299: kp->bsel1 = ROMI|ROMO; ! 300: sav = kp->sel6; ! 301: kp->bsel1 = ROMI; ! 302: kp->sel6 = kk.kval; ! 303: kp->bsel1 = ROMI|STEP; ! 304: kp->bsel1 = ROMI; ! 305: kp->sel6 = sav; ! 306: kp->bsel1 = 0; ! 307: goto lcsr; ! 308: case KSTEP: ! 309: if (tp->k_stat&SRUN) ! 310: break; ! 311: kp->bsel1 |= STEP; ! 312: kp->bsel1 = 0; ! 313: case KCSR: ! 314: lcsr: ! 315: csr[0] = kp->sel0; ! 316: csr[1] = kp->sel2; ! 317: csr[2] = kp->sel4; ! 318: csr[3] = kp->sel6; ! 319: if (copyout(csr, kk.kcsr, sizeof csr)) ! 320: u.u_error = EFAULT; ! 321: return; ! 322: case KWRCR: ! 323: if (tp->k_stat&SRINT) ! 324: break; ! 325: kp->sel6 = kk.kval; ! 326: return; ! 327: case KRUN: ! 328: if (tp->k_stat&SRUN) ! 329: break; ! 330: tp->k_stat &= ~STYPE; ! 331: tp->k_stat |= (kk.kval&STYPE)|SRUN; ! 332: kp->bsel1 |= RUN; ! 333: if (tp->k_stat&SRINT) { ! 334: spl5(); ! 335: kmcrint(dev); ! 336: spl0(); ! 337: } ! 338: return; ! 339: case KLU: ! 340: kp->bsel1 = kk.kval&(LUA|LUB); ! 341: return; ! 342: } ! 343: u.u_error = EIO; ! 344: } ! 345: ! 346: kmcrint(dev) ! 347: dev_t dev; ! 348: { ! 349: if (kdirint) ! 350: (*kdirint)(); ! 351: } ! 352: ! 353: kmcxint(dev) ! 354: { ! 355: if (kdixint) ! 356: (*kdixint)(); ! 357: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.