![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ps.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vaxuba|
Return to ps.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vaxuba |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: * ! 6: * @(#)ps.c 7.1 (Berkeley) 6/5/86 ! 7: */ ! 8: ! 9: /* ! 10: * Evans and Sutherland Picture System 2 driver -- Bill Reeves. ! 11: */ ! 12: ! 13: /* ! 14: * Still to be done: ! 15: * WAIT_HIT ! 16: */ ! 17: ! 18: #include "ps.h" ! 19: #if NPS > 0 ! 20: ! 21: #define EXTERNAL_SYNC ! 22: ! 23: #include "../machine/pte.h" ! 24: ! 25: #include "param.h" ! 26: #include "systm.h" ! 27: #include "ioctl.h" ! 28: #include "map.h" ! 29: #include "buf.h" ! 30: #include "conf.h" ! 31: #include "dir.h" ! 32: #include "user.h" ! 33: #include "uio.h" ! 34: ! 35: #include "ubareg.h" ! 36: #include "ubavar.h" ! 37: #include "psreg.h" ! 38: ! 39: int psprobe(), psattach(), psextsync(); ! 40: int psclockintr(), pssystemintr(), psdeviceintr(), psdmaintr(); ! 41: struct uba_device *psdinfo[NPS]; ! 42: u_short psstd[] = { 0 }; ! 43: struct uba_driver psdriver = ! 44: { psprobe, 0, psattach, 0, psstd, "ps", psdinfo }; ! 45: ! 46: #define PSUNIT(dev) (minor(dev)) ! 47: ! 48: #define MAXAUTOREFRESH 4 ! 49: #define MAXAUTOMAP 4 ! 50: #define MAXDBSIZE (0177777/2) ! 51: ! 52: #define PSPRI (PZERO+1) ! 53: ! 54: #define PSWAIT(psaddr) { \ ! 55: register short i = 20000, j; \ ! 56: while (i-- != 0 && ((j = psaddr->ps_iostat) & DIOREADY) == 0) \ ! 57: ;\ ! 58: } ! 59: ! 60: struct psrefresh { ! 61: enum { ! 62: SINGLE_STEP_RF, ! 63: AUTO_RF, ! 64: TIME_RF ! 65: } state; ! 66: enum { ! 67: RUNNING_RF, ! 68: SYNCING_RF, ! 69: WAITING_MAP, ! 70: STOPPED_RF ! 71: } mode; ! 72: u_short sraddrs[MAXAUTOREFRESH]; ! 73: short nsraddrs; ! 74: short srcntr; ! 75: char waiting; ! 76: char stop; ! 77: int icnt; ! 78: int timecnt; ! 79: }; ! 80: ! 81: struct psdbuffer { ! 82: enum { ! 83: ON_DB, ! 84: OFF_DB ! 85: } state; ! 86: u_short dbaddrs[2]; ! 87: u_short dbsize; ! 88: short rbuffer; ! 89: }; ! 90: ! 91: struct psmap { ! 92: enum { ! 93: SINGLE_STEP_MAP, ! 94: AUTO_MAP ! 95: } state; ! 96: enum { ! 97: RUNNING_MAP, ! 98: WAITING_RF, ! 99: WAITING_START, ! 100: STOPPED_MAP ! 101: } mode; ! 102: u_short maddrs[MAXAUTOMAP]; ! 103: short nmaddrs; ! 104: short mcntr; ! 105: short outputstart; ! 106: char waiting; ! 107: char stop; ! 108: int icnt; ! 109: }; ! 110: ! 111: /* ! 112: * PS2 software state. ! 113: */ ! 114: struct ps { ! 115: char ps_open; /* device is open */ ! 116: uid_t ps_uid; /* uid of device owner */ ! 117: struct psrefresh ps_refresh; /* refresh state */ ! 118: struct psdbuffer ps_dbuffer; /* double buffering state */ ! 119: struct psmap ps_map; /* segment map state */ ! 120: int ps_clockticks; /* clock ints between refresh */ ! 121: int ps_clockmiss; /* clock ints w/o refresh */ ! 122: int ps_clockcnt; /* count of clock interrupts */ ! 123: int ps_hitcnt; /* count of hit interrupts */ ! 124: int ps_strayintr; /* count of stray interrupts */ ! 125: int ps_icnt; /* count of system interrupts */ ! 126: /* BEGIN GROT */ ! 127: int ps_lastrequest; ! 128: int ps_lastrequest2; ! 129: int ps_lastfunnyrequest; ! 130: int ps_funnycnt; ! 131: /* END GROT */ ! 132: } ps[NPS]; ! 133: ! 134: psprobe(reg) ! 135: caddr_t reg; ! 136: { ! 137: register int br, cvec; ! 138: register struct psdevice *psaddr = (struct psdevice *)reg; ! 139: ! 140: #ifdef lint ! 141: br = 0; cvec = br; br = cvec; ! 142: psclockintr((dev_t)0); pssystemintr((dev_t)0); ! 143: psdeviceintr((dev_t)0); psdmaintr((dev_t)0); ! 144: psextsync(0, 0); ! 145: #endif ! 146: psaddr->ps_iostat = PSRESET; ! 147: DELAY(200); ! 148: psaddr->ps_addr = RTCIE; ! 149: PSWAIT(psaddr); psaddr->ps_data = 01; ! 150: psaddr->ps_iostat = PSIE; ! 151: psaddr->ps_addr = RTCSR; ! 152: PSWAIT(psaddr); psaddr->ps_data = SYNC|RUN; ! 153: DELAY(200000); ! 154: psaddr->ps_addr = RTCREQ; ! 155: PSWAIT(psaddr); psaddr->ps_data = 01; ! 156: psaddr->ps_iostat = 0; ! 157: psaddr->ps_iostat = PSRESET; ! 158: return (sizeof (struct psdevice)); ! 159: } ! 160: ! 161: /*ARGSUSED*/ ! 162: psattach(ui) ! 163: struct uba_device *ui; ! 164: { ! 165: ! 166: } ! 167: ! 168: psopen(dev) ! 169: dev_t dev; ! 170: { ! 171: register struct ps *psp; ! 172: register struct uba_device *ui; ! 173: register int unit = PSUNIT(dev); ! 174: ! 175: if (unit >= NPS || (psp = &ps[minor(dev)])->ps_open || ! 176: (ui = psdinfo[unit]) == 0 || ui->ui_alive == 0) ! 177: return (ENXIO); ! 178: psp->ps_open = 1; ! 179: psp->ps_uid = u.u_uid; ! 180: psp->ps_strayintr = 0; ! 181: psp->ps_refresh.state = SINGLE_STEP_RF; ! 182: psp->ps_refresh.mode = STOPPED_RF; ! 183: psp->ps_refresh.waiting = 0; ! 184: psp->ps_refresh.stop = 0; ! 185: psp->ps_dbuffer.state = OFF_DB; ! 186: psp->ps_map.state = SINGLE_STEP_MAP; ! 187: psp->ps_map.mode = STOPPED_MAP; ! 188: psp->ps_map.waiting = 0; ! 189: psp->ps_map.stop = 0; ! 190: psp->ps_clockticks = 0; ! 191: psp->ps_clockmiss = 0; ! 192: psp->ps_refresh.icnt = psp->ps_map.icnt = psp->ps_clockcnt = 0; ! 193: psp->ps_hitcnt = 0; ! 194: psp->ps_icnt = 0; ! 195: maptouser(ui->ui_addr); ! 196: return (0); ! 197: } ! 198: ! 199: psclose(dev) ! 200: dev_t dev; ! 201: { ! 202: register struct psdevice *psaddr = ! 203: (struct psdevice *)psdinfo[PSUNIT(dev)]->ui_addr; ! 204: ! 205: ps[PSUNIT(dev)].ps_open = 0; ! 206: psaddr->ps_iostat = 0; /* clear IENABLE */ ! 207: PSWAIT(psaddr); psaddr->ps_addr = RFSR; /* set in auto refresh mode */ ! 208: PSWAIT(psaddr); psaddr->ps_data = AUTOREF; ! 209: unmaptouser((caddr_t)psaddr); ! 210: } ! 211: ! 212: /*ARGSUSED*/ ! 213: psread(dev, uio) ! 214: dev_t dev; ! 215: struct uio *uio; ! 216: { ! 217: } ! 218: ! 219: /*ARGSUSED*/ ! 220: pswrite(dev, uio) ! 221: dev_t dev; ! 222: struct uio *uio; ! 223: { ! 224: } ! 225: ! 226: /*ARGSUSED*/ ! 227: psioctl(dev, cmd, data, flag) ! 228: register caddr_t data; ! 229: { ! 230: register struct uba_device *ui = psdinfo[PSUNIT(dev)]; ! 231: register struct ps *psp = &ps[PSUNIT(dev)]; ! 232: int *waddr = *(int **)data; ! 233: int n, arg, i; ! 234: ! 235: switch (cmd) { ! 236: ! 237: case PSIOGETADDR: ! 238: *(caddr_t *)data = ui->ui_addr; ! 239: break; ! 240: ! 241: case PSIOAUTOREFRESH: ! 242: n = fuword((caddr_t)waddr++); ! 243: if (n == -1) ! 244: return (EFAULT); ! 245: if (n < 0 || n > MAXAUTOREFRESH) ! 246: return (EINVAL); ! 247: for (i = 0; i < n; i++) { ! 248: if ((arg = fuword((caddr_t)waddr++)) == -1) ! 249: return (EFAULT); ! 250: psp->ps_refresh.sraddrs[i] = arg; ! 251: } ! 252: psp->ps_refresh.state = AUTO_RF; ! 253: psp->ps_refresh.nsraddrs = n; ! 254: psp->ps_refresh.srcntr = 0; ! 255: psp->ps_refresh.mode = WAITING_MAP; ! 256: break; ! 257: ! 258: case PSIOAUTOMAP: ! 259: n = fuword((caddr_t)waddr++); ! 260: if (n == -1) ! 261: return (EFAULT); ! 262: if (n < 0 || n > MAXAUTOMAP) ! 263: return (EINVAL); ! 264: for (i = 0; i < n; i++) { ! 265: if ((arg = fuword((caddr_t)waddr++)) == -1) ! 266: return (EFAULT); ! 267: psp->ps_map.maddrs[i] = arg; ! 268: } ! 269: if ((arg = fuword((caddr_t)waddr++)) == -1) ! 270: return (EFAULT); ! 271: psp->ps_map.outputstart = arg; ! 272: psp->ps_map.state = AUTO_MAP; ! 273: psp->ps_map.nmaddrs = n; ! 274: psp->ps_map.mcntr = 0; ! 275: psp->ps_map.mode = WAITING_START; ! 276: break; ! 277: ! 278: case PSIOSINGLEREFRESH: ! 279: psp->ps_refresh.state = SINGLE_STEP_RF; ! 280: break; ! 281: ! 282: case PSIOSINGLEMAP: ! 283: psp->ps_map.state = SINGLE_STEP_MAP; ! 284: break; ! 285: ! 286: case PSIODOUBLEBUFFER: ! 287: if ((arg = fuword((caddr_t)waddr++)) == -1) ! 288: return (EFAULT); ! 289: psp->ps_dbuffer.dbaddrs[0] = arg; ! 290: if ((arg = fuword((caddr_t)waddr++)) == -1) ! 291: return (EFAULT); ! 292: if (arg <= 0 || arg > MAXDBSIZE) ! 293: return (EINVAL); ! 294: psp->ps_dbuffer.dbsize = arg; ! 295: psp->ps_dbuffer.dbaddrs[1] = psp->ps_dbuffer.dbaddrs[0]+arg; ! 296: psp->ps_dbuffer.state = ON_DB; ! 297: psp->ps_dbuffer.rbuffer = 0; ! 298: break; ! 299: ! 300: case PSIOSINGLEBUFFER: ! 301: psp->ps_dbuffer.state = OFF_DB; ! 302: break; ! 303: ! 304: case PSIOTIMEREFRESH: ! 305: if (psp->ps_refresh.state != SINGLE_STEP_RF) ! 306: return (EINVAL); ! 307: if ((arg = fuword((caddr_t)waddr++)) == -1) ! 308: return (EFAULT); ! 309: psp->ps_refresh.state = TIME_RF; ! 310: psp->ps_refresh.timecnt = arg; ! 311: break; ! 312: ! 313: case PSIOWAITREFRESH: ! 314: if (psp->ps_refresh.mode != RUNNING_RF) /* not running */ ! 315: return (0); /* dont wait */ ! 316: /* fall into ... */ ! 317: ! 318: case PSIOSTOPREFRESH: ! 319: if (cmd == PSIOSTOPREFRESH) { ! 320: if (psp->ps_refresh.mode == STOPPED_RF && ! 321: psp->ps_refresh.state != TIME_RF) ! 322: return (0); ! 323: psp->ps_refresh.stop = 1; ! 324: } ! 325: (void) spl5(); ! 326: psp->ps_refresh.waiting = 1; ! 327: while (psp->ps_refresh.waiting) ! 328: sleep(&psp->ps_refresh.waiting, PSPRI); ! 329: (void) spl0(); ! 330: if (cmd == PSIOSTOPREFRESH) ! 331: psp->ps_refresh.mode = STOPPED_RF; ! 332: if (psp->ps_refresh.state == TIME_RF) ! 333: psp->ps_refresh.state = SINGLE_STEP_RF; ! 334: break; ! 335: ! 336: case PSIOWAITMAP: ! 337: if (psp->ps_map.mode != RUNNING_MAP) /* not running */ ! 338: return (0); /* dont wait */ ! 339: /* fall into ... */ ! 340: ! 341: case PSIOSTOPMAP: ! 342: if (cmd == PSIOSTOPMAP) ! 343: psp->ps_map.stop = 1; ! 344: (void) spl5(); ! 345: psp->ps_map.waiting = 1; ! 346: while (psp->ps_map.waiting) ! 347: sleep(&psp->ps_map.waiting, PSPRI); ! 348: (void) spl0(); ! 349: break; ! 350: ! 351: default: ! 352: return (ENOTTY); ! 353: break; ! 354: } ! 355: return (0); ! 356: } ! 357: ! 358: #define SAVEPSADDR(psaddr, savepsaddr) { \ ! 359: register short i, xx1; \ ! 360: xx1 = splclock(); \ ! 361: i = psaddr->ps_addr; \ ! 362: while ((psaddr->ps_iostat & DIOREADY) == 0) \ ! 363: ; \ ! 364: savepsaddr = psaddr->ps_data; \ ! 365: splx(xx1); \ ! 366: } ! 367: #define RESTORPSADDR(psaddr, savepsaddr) { \ ! 368: register short xx2; \ ! 369: xx2 = splclock(); \ ! 370: while ((psaddr->ps_iostat & DIOREADY) == 0) \ ! 371: ;\ ! 372: psaddr->ps_addr = savepsaddr; \ ! 373: splx(xx2); \ ! 374: } ! 375: ! 376: psclockintr(dev) ! 377: dev_t dev; ! 378: { ! 379: register struct psdevice *psaddr = ! 380: (struct psdevice *)psdinfo[PSUNIT(dev)]->ui_addr; ! 381: register struct ps *psp = &ps[PSUNIT(dev)]; ! 382: int savepsaddr; ! 383: ! 384: if (!psp->ps_open) ! 385: return; ! 386: psp->ps_clockcnt++; ! 387: SAVEPSADDR(psaddr, savepsaddr); ! 388: #ifndef EXTERNAL_SYNC ! 389: if (psp->ps_refresh.state == AUTO_RF) { ! 390: if (psp->ps_refresh.mode == SYNCING_RF && ! 391: psp->ps_refresh.state != TIME_RF) { ! 392: (void) psrfnext(psp, psaddr); ! 393: } else { ! 394: psp->ps_clockticks++; ! 395: psp->ps_clockmiss++; ! 396: } ! 397: } ! 398: #endif ! 399: PSWAIT(psaddr); psaddr->ps_addr = RTCREQ; ! 400: PSWAIT(psaddr); psaddr->ps_data = 01; /* clear the request bits */ ! 401: RESTORPSADDR(psaddr, savepsaddr); ! 402: } ! 403: ! 404: /*ARGSUSED*/ ! 405: pssystemintr(dev) ! 406: dev_t dev; ! 407: { ! 408: register struct psdevice *psaddr = ! 409: (struct psdevice *)psdinfo[PSUNIT(dev)]->ui_addr; ! 410: register struct ps *psp = &ps[PSUNIT(dev)]; ! 411: short request, tmp; ! 412: register int savepsaddr, x; ! 413: ! 414: if (!psp->ps_open) ! 415: return; ! 416: psp->ps_icnt++; ! 417: SAVEPSADDR(psaddr, savepsaddr); ! 418: PSWAIT(psaddr); psaddr->ps_addr = SYSREQ; ! 419: PSWAIT(psaddr); request = psaddr->ps_data; ! 420: request = request&0377; ! 421: psp->ps_lastrequest2 = psp->ps_lastrequest; ! 422: psp->ps_lastrequest = request; ! 423: if (request &~ (HALT_REQ|RFSTOP_REQ|HIT_REQ)) { ! 424: psp->ps_lastfunnyrequest = request; ! 425: psp->ps_funnycnt++; ! 426: } ! 427: PSWAIT(psaddr); psaddr->ps_addr = SYSREQ; ! 428: tmp = request&(~(HALT_REQ|MOSTOP_REQ)); /* acknowledge */ ! 429: PSWAIT(psaddr); psaddr->ps_data = tmp; ! 430: ! 431: if (request & (MOSTOP_REQ|HALT_REQ)) { /* Map stopped */ ! 432: psp->ps_map.icnt++; ! 433: psmapstop(psaddr, psp, request);/* kill it dead */ ! 434: if (psp->ps_map.waiting) { ! 435: psp->ps_map.waiting = 0; ! 436: wakeup(&psp->ps_map.waiting); ! 437: if (psp->ps_map.stop) { ! 438: psp->ps_map.stop = 0; ! 439: goto tryrf; ! 440: } ! 441: } ! 442: if (psp->ps_map.state == AUTO_MAP && !psmapnext(psp, psaddr)) { ! 443: psp->ps_map.mcntr = 0; ! 444: /* prepare for next round */ ! 445: pssetmapbounds(psp, psaddr); ! 446: if (psp->ps_refresh.state == AUTO_RF) { ! 447: if (psp->ps_refresh.mode == WAITING_MAP){ ! 448: if (psp->ps_dbuffer.state == ON_DB) ! 449: /* fill other db */ ! 450: psdbswitch(psp, psaddr); ! 451: else ! 452: psp->ps_map.mode = WAITING_RF; ! 453: #ifdef EXTERNAL_SYNC ! 454: x = splclock(); ! 455: #endif ! 456: (void) psrfnext(psp, psaddr); ! 457: #ifdef EXTERNAL_SYNC ! 458: splx(x); ! 459: #endif ! 460: } else ! 461: psp->ps_map.mode = WAITING_RF; ! 462: } else { /* no auto refresh */ ! 463: if (psp->ps_dbuffer.state == ON_DB) ! 464: /* fill other db */ ! 465: psdbswitch(psp, psaddr); ! 466: else ! 467: (void) psmapnext(psp, psaddr); ! 468: } ! 469: } ! 470: } ! 471: tryrf: ! 472: if (request & RFSTOP_REQ) { /* Refresh stopped */ ! 473: psp->ps_refresh.icnt++; ! 474: if (psp->ps_refresh.state == TIME_RF) ! 475: if (--psp->ps_refresh.timecnt > 0) ! 476: goto tryhit; ! 477: psrfstop(psaddr, psp); ! 478: if (psp->ps_refresh.waiting) { ! 479: psp->ps_refresh.waiting = 0; ! 480: wakeup(&psp->ps_refresh.waiting); ! 481: if (psp->ps_refresh.stop) { ! 482: psp->ps_refresh.stop = 0; ! 483: goto tryhit; ! 484: } ! 485: } ! 486: if (psp->ps_refresh.state == AUTO_RF) ! 487: if (!psrfnext(psp, psaddr)) { /* at end of refresh cycle */ ! 488: if (psp->ps_map.state == AUTO_MAP && ! 489: psp->ps_map.mode == WAITING_RF) { ! 490: if (psp->ps_dbuffer.state == ON_DB) ! 491: psdbswitch(psp, psaddr); ! 492: else ! 493: (void) psmapnext(psp, psaddr); ! 494: } ! 495: psp->ps_refresh.srcntr = 0; ! 496: #ifdef EXTERNAL_SYNC ! 497: x = splclock(); ! 498: #endif ! 499: psp->ps_refresh.mode = SYNCING_RF; ! 500: if (psp->ps_clockticks) ! 501: (void) psrfnext(psp, psaddr); ! 502: psp->ps_clockticks = 0; ! 503: #ifdef EXTERNAL_SYNC ! 504: splx(x); ! 505: #endif ! 506: } ! 507: } ! 508: tryhit: ! 509: if (request & HIT_REQ) /* Hit request */ ! 510: psp->ps_hitcnt++; ! 511: if (request == 0) ! 512: psp->ps_strayintr++; ! 513: RESTORPSADDR(psaddr, savepsaddr); ! 514: } ! 515: ! 516: psrfnext(psp, psaddr) ! 517: register struct ps *psp; ! 518: register struct psdevice *psaddr; ! 519: { ! 520: u_short start, last; ! 521: ! 522: if (psp->ps_refresh.srcntr < psp->ps_refresh.nsraddrs) { ! 523: psrfstart(psp->ps_refresh.sraddrs[psp->ps_refresh.srcntr++], ! 524: 0, psp, psaddr); ! 525: return (1); ! 526: } ! 527: if (psp->ps_refresh.srcntr == psp->ps_refresh.nsraddrs && ! 528: psp->ps_dbuffer.state == ON_DB) { ! 529: start = psp->ps_dbuffer.dbaddrs[psp->ps_dbuffer.rbuffer]; ! 530: last = start+psp->ps_dbuffer.dbsize; ! 531: psrfstart(start, last, psp, psaddr); ! 532: psp->ps_refresh.srcntr++; /* flag for after dbuffer */ ! 533: return (1); ! 534: } ! 535: return (0); ! 536: } ! 537: ! 538: psrfstart(dfaddr, last, psp, psaddr) ! 539: u_short dfaddr, last; ! 540: register struct ps *psp; ! 541: register struct psdevice *psaddr; ! 542: { ! 543: short dummy; ! 544: ! 545: PSWAIT(psaddr); psaddr->ps_addr = RFASA; ! 546: PSWAIT(psaddr); psaddr->ps_data = dfaddr; ! 547: PSWAIT(psaddr); ! 548: if (last != 0) ! 549: psaddr->ps_data = last; ! 550: else ! 551: dummy = psaddr->ps_data;/* just access to get to status reg */ ! 552: PSWAIT(psaddr); psaddr->ps_data = RFSTART; /* may want | here */ ! 553: psp->ps_refresh.mode = RUNNING_RF; ! 554: } ! 555: ! 556: /*ARGSUSED*/ ! 557: psrfstop(psaddr, psp) ! 558: register struct psdevice *psaddr; ! 559: register struct ps *psp; ! 560: { ! 561: ! 562: PSWAIT(psaddr); psaddr->ps_addr = RFSR; ! 563: PSWAIT(psaddr); psaddr->ps_data = 0; ! 564: } ! 565: ! 566: psdbswitch(psp, psaddr) ! 567: register struct ps *psp; ! 568: register struct psdevice *psaddr; ! 569: { ! 570: ! 571: psp->ps_dbuffer.rbuffer = !psp->ps_dbuffer.rbuffer; ! 572: pssetmapbounds(psp, psaddr); ! 573: (void) psmapnext(psp, psaddr); ! 574: } ! 575: ! 576: psmapnext(psp, psaddr) ! 577: register struct ps *psp; ! 578: register struct psdevice *psaddr; ! 579: { ! 580: ! 581: if (psp->ps_map.mcntr < psp->ps_map.nmaddrs) { ! 582: psmapstart(psp->ps_map.maddrs[psp->ps_map.mcntr++], ! 583: psp, psaddr); ! 584: return (1); ! 585: } ! 586: return (0); ! 587: } ! 588: ! 589: pssetmapbounds(psp, psaddr) ! 590: register struct ps *psp; ! 591: register struct psdevice *psaddr; ! 592: { ! 593: u_short start, last; ! 594: ! 595: PSWAIT(psaddr); psaddr->ps_addr = MAOL; ! 596: PSWAIT(psaddr); ! 597: if (psp->ps_dbuffer.state == ON_DB) { ! 598: start = psp->ps_dbuffer.dbaddrs[!psp->ps_dbuffer.rbuffer]; ! 599: last = start+psp->ps_dbuffer.dbsize-2; /* 2 for halt cmd */ ! 600: psaddr->ps_data = last; ! 601: PSWAIT(psaddr); psaddr->ps_data = start; ! 602: } else { ! 603: start = psaddr->ps_data; /* dummy: don't update limit */ ! 604: PSWAIT(psaddr); psaddr->ps_data = psp->ps_map.outputstart; ! 605: } ! 606: } ! 607: ! 608: psmapstart(dfaddr, psp, psaddr) ! 609: u_short dfaddr; ! 610: register struct ps *psp; ! 611: register struct psdevice *psaddr; ! 612: { ! 613: ! 614: PSWAIT(psaddr); psaddr->ps_addr = MAIA; ! 615: PSWAIT(psaddr); psaddr->ps_data = dfaddr; ! 616: PSWAIT(psaddr); psaddr->ps_data = MAO|MAI; /* may want more here */ ! 617: psp->ps_map.mode = RUNNING_MAP; ! 618: } ! 619: ! 620: int pskillcnt = 1; ! 621: ! 622: psmapstop(psaddr, psp, request) ! 623: register struct psdevice *psaddr; ! 624: register struct ps *psp; ! 625: short request; ! 626: { ! 627: register int i; ! 628: ! 629: request &= HALT_REQ|MOSTOP_REQ; /* overkill?? */ ! 630: for (i = 0; i < pskillcnt; i++) { ! 631: PSWAIT(psaddr); psaddr->ps_addr = MASR; ! 632: PSWAIT(psaddr); psaddr->ps_data = IOUT; /* zero MAI & MAO */ ! 633: PSWAIT(psaddr); psaddr->ps_addr = MAIA; ! 634: PSWAIT(psaddr); psaddr->ps_data = 0; /* 0 input addr reg */ ! 635: PSWAIT(psaddr); psaddr->ps_addr = MAOA; ! 636: PSWAIT(psaddr); psaddr->ps_data = 0; /* 0 output addr reg */ ! 637: PSWAIT(psaddr); psaddr->ps_addr = SYSREQ; ! 638: PSWAIT(psaddr); psaddr->ps_data = request; ! 639: } ! 640: psp->ps_map.mode = STOPPED_MAP; ! 641: } ! 642: ! 643: /*ARGSUSED*/ ! 644: psdeviceintr(dev) ! 645: dev_t dev; ! 646: { ! 647: ! 648: printf("ps device intr\n"); ! 649: } ! 650: ! 651: /*ARGSUSED*/ ! 652: psdmaintr(dev) ! 653: dev_t dev; ! 654: { ! 655: ! 656: printf("ps dma intr\n"); ! 657: } ! 658: ! 659: /*ARGSUSED*/ ! 660: psreset(uban) ! 661: int uban; ! 662: { ! 663: ! 664: } ! 665: ! 666: /*ARGSUSED*/ ! 667: psextsync(PC, PS) ! 668: { ! 669: register int n; ! 670: register struct psdevice *psaddr; ! 671: register struct ps *psp; ! 672: register int savepsaddr; ! 673: ! 674: #ifdef EXTERNAL_SYNC ! 675: for (psp = ps, n = 0; n < NPS; psp++, n++) { ! 676: if (!psp->ps_open) ! 677: continue; ! 678: if (psp->ps_refresh.mode == SYNCING_RF && ! 679: psp->ps_refresh.state != TIME_RF) { ! 680: psaddr = (struct psdevice *)psdinfo[n]->ui_addr; ! 681: SAVEPSADDR(psaddr, savepsaddr); ! 682: (void) psrfnext(psp, psaddr); ! 683: RESTORPSADDR(psaddr, savepsaddr); ! 684: } else { ! 685: psp->ps_clockticks++; ! 686: psp->ps_clockmiss++; ! 687: } ! 688: } ! 689: #endif ! 690: } ! 691: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.