![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vs.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 vs.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vaxuba |
1.1 root 1: /* @(#)vs.c 7.1 (MIT) 6/5/86 */
2: /****************************************************************************
3: * *
4: * Copyright (c) 1983, 1984 by *
5: * DIGITAL EQUIPMENT CORPORATION, Maynard, Massachusetts. *
6: * All rights reserved. *
7: * *
8: * This software is furnished on an as-is basis and may be used and copied *
9: * only with inclusion of the above copyright notice. This software or any *
10: * other copies thereof may be provided or otherwise made available to *
11: * others only for non-commercial purposes. No title to or ownership of *
12: * the software is hereby transferred. *
13: * *
14: * The information in this software is subject to change without notice *
15: * and should not be construed as a commitment by DIGITAL EQUIPMENT *
16: * CORPORATION. *
17: * *
18: * DIGITAL assumes no responsibility for the use or reliability of its *
19: * software on equipment which is not supplied by DIGITAL. *
20: * *
21: * *
22: ****************************************************************************/
23:
24: #include "vs.h"
25: #if NVS > 0
26:
27: #include "../machine/pte.h"
28:
29: #include "param.h"
30: #include "dir.h"
31: #include "user.h"
32: #include "buf.h"
33: #include "systm.h"
34: #include "map.h"
35: #include "kernel.h"
36: #include "ioctl.h"
37:
38: #include "vsio.h"
39:
40: #include "proc.h"
41: #include "uio.h"
42: #include "vmmac.h"
43: #include "file.h"
44:
45: #include "ubareg.h"
46: #include "ubavar.h"
47: #include "vsreg.h"
48:
49: #include "../vax/mtpr.h"
50:
51: #define VSWAITPRI (PZERO+1)
52: #define VSMAXEVQ 64 /* must be power of 2 */
53: #define EVROUND(x) ((x) & (VSMAXEVQ - 1))
54:
55:
56: #define VSBUFFSIZE 3072
57: struct vsBuffArea {
58: vsIoAddr vsioa;
59: char obuff[VSBUFFSIZE];
60: vsEvent ibuff[VSMAXEVQ];
61: };
62: struct vsBuffArea vsBuff[NVS];
63:
64:
65: int vsprobe(), vsattach();
66: struct uba_device *vsdinfo[NVS];
67: u_short vsstd[] = { 0 };
68: struct uba_driver vsdriver =
69: { vsprobe, 0, vsattach, 0, vsstd, "vs", vsdinfo, 0, 0 };
70:
71: #define VSUNIT(dev) (minor(dev))
72:
73: struct vs_softc {
74: unsigned inited : 1; /* has this ever been inited? */
75: unsigned open : 1; /* only one open, please */
76: unsigned linkAvail : 1; /* link is up */
77: short pgrp; /* process group for SIGHUP */
78: int romVersion; /* rom version */
79: struct vs_fparm offset; /* address base */
80: struct vs_csr csr; /* saved csr0 */
81: struct vs_intr irr; /* saved interrupt reason */
82: struct vs_kbd krr; /* saved keyboard */
83: struct vs_fparm pr; /* saved parameter regs */
84: struct proc *rsel; /* process waiting for select */
85: struct vs_fparm vs_nextgo; /* next packet to go */
86: short vs_status; /* status from previous packet */
87: vsStats stats; /* statistics */
88: int vsBuff_ubinfo; /* ubinfo for vsBuff */
89: }vs_softc[NVS];
90:
91: #define TRUE 1
92: #define FALSE 0
93:
94: #define printI if (vsIntrPrintfs)printf
95: #define printD if (vsDebugPrintfs)printf
96: #define printM if (vsMlpPrintfs) vsMlpPrintfs--,printf
97: int vsIntrPrintfs = 0;
98: int vsDebugPrintfs = 0;
99: int vsMlpPrintfs = 0;
100:
101: /*
102: * Tell the system that it's out there, and set up the device's interrupt
103: * vector. Since we are supporting vs100s and vs125s,
104: * this is a bit kludgey. The vs100 works much
105: * as one expects, but the vs125 tries to set all the fiber link
106: * related bits when you hit VS_IE, ignoring the way the 100 works.
107: * Also, the vs100 will let you set the interrupt vector, but
108: * the vs125 ignores this and uses its hard-wired value.
109: * And there's no sure fire to tell which variant it is.
110: * Ugh. Ugh. Ugh.
111: */
112:
113: vsprobe(reg)
114: caddr_t reg;
115: {
116: register int br, cvec; /* value-result */
117: register struct vsdevice *vsaddr = (struct vsdevice *)reg;
118:
119: #ifdef lint
120: br = 0; cvec = br; br = cvec;
121: vsintr(0);
122: #endif
123: br = 0x15;
124: cvec = (uba_hd[numuba].uh_lastiv -= 4*8);
125: /*
126: * uh_lastiv is the last free interrupt vector in the
127: * unibus addapter header (uba_hd).
128: */
129:
130: vsaddr->vs_csr0 = cvec >> 2; /* Save the vector for use on next device */
131: vsaddr->vs_irr = 0; /* Csr will only be read if irr == 0 */
132: vsaddr->vs_irr = 0; /* Clear interrupt reason register */
133: vsaddr->vs_pr1 = 0; /* Clear function parameter */
134: vsaddr->vs_pr2 = 0; /* Clear function parameter */
135: vsaddr->vs_ivr = cvec; /* set up vector (no-op for vs125) */
136:
137: DELAY(100000);
138: if (vsaddr->vs_csr0 & VS_LNK_AVL)
139: return(0); /* light won't go off! */
140: vsaddr->vs_csr0 &= ~VS_LNK_TRNS;
141: vsaddr->vs_csr0 |= VS_IE; /* enable interrupts */
142: DELAY(200000);
143:
144: return sizeof(struct vsdevice);
145: }
146:
147: vsattach(uip)
148: struct uba_device *uip;
149: {
150: register struct vs_softc *vsp;
151: register struct vsdevice *vsaddr;
152:
153: vsp = &vs_softc[VSUNIT(uip->ui_unit)];
154: vsp->inited = FALSE;
155: vsp->open = FALSE;
156: vsBuff[VSUNIT(uip->ui_unit)].vsioa.mbox.bottom = 0;
157: vsp->linkAvail = FALSE;
158: vsp->romVersion = 0;
159: vsp->vs_nextgo.fparm_all = NULL;
160:
161: vsaddr = (struct vsdevice *) uip->ui_addr;
162: vsaddr->vs_csr0 |= (VS_IE | VS_XMIT_ON);
163: }
164:
165: vsopen(dev, flag)
166: dev_t dev;
167: int flag;
168: {
169: register struct vs_softc *vsp;
170: register struct uba_device *uip;
171: register struct vsdevice *vsaddr;
172: int s;
173: int ret;
174: struct buf vsbuf;
175: struct vsBuffArea *vsb;
176: caddr_t vsBuffpage;
177: int vsBuffnpages;
178:
179: if (VSUNIT(dev) >= NVS || (vsp = &vs_softc[VSUNIT(dev)])->open ||
180: (uip = vsdinfo[VSUNIT(dev)]) == 0 || uip->ui_alive == 0)
181: return (ENXIO);
182:
183: vsaddr = (struct vsdevice *) uip->ui_addr;
184: vsb = &vsBuff[VSUNIT(dev)];
185: printM("vsopen csr0=%x, csr1=%x, csr2=%x, csr3=%x, csr4=%x, csr5=%x, csr6=%x, csr7=%x\n",
186: vsaddr->vs_csr0, vsaddr->vs_csr1, vsaddr->vs_csr2, vsaddr->vs_csr3,
187: vsaddr->vs_csr4, vsaddr->vs_csr5, vsaddr->vs_csr6, vsaddr->vs_csr7);
188:
189: /*
190: * Finally! We can now set up the device.
191: */
192:
193: if (!vsp->inited && !(flag & FNDELAY)) {
194: vsInitDev(dev, TRUE);
195: if (ret = vsError(vsp))
196: return(ret);
197: }
198:
199: vsp->open = TRUE; /* we're open */
200: vsp->pgrp = u.u_procp->p_pgrp;
201:
202: /* reset statistics */
203: bzero((caddr_t) &vsp->stats, sizeof(vsStats));
204:
205: /* initialize user I/O addresses */
206: vsb->vsioa.ioreg = (short *)vsaddr;
207: vsb->vsioa.status = 0;
208: vsb->vsioa.obuff = vsb->obuff;
209: vsb->vsioa.obufflen = VSBUFFSIZE;
210: vsb->vsioa.ibuff = vsb->ibuff;
211: vsb->vsioa.ihead = 0;
212: vsb->vsioa.itail = 0;
213: vsb->vsioa.iqsize = VSMAXEVQ;
214: /* map io regs into user address space (assume they don't cross a page) */
215: maptouser(vsaddr);
216: /* map vsBuff into user address space */
217: vsBuffpage = (caddr_t)((int)vsb & ~PGOFSET);
218: vsBuffnpages = (((int)vsb & PGOFSET) +
219: (NBPG-1) + sizeof(struct vsBuffArea)) >> PGSHIFT;
220: while (vsBuffnpages>0) {
221: maptouser(vsBuffpage);
222: vsBuffpage += NBPG;
223: vsBuffnpages--;
224: }
225: /* lock in the buffer */
226: vsbuf.b_error = 0;
227: vsbuf.b_proc = u.u_procp;
228: vsbuf.b_un.b_addr = vsb->obuff;
229: vsbuf.b_flags = B_BUSY;
230: vsbuf.b_bcount = VSBUFFSIZE;
231: vsp->vsBuff_ubinfo = ubasetup(uip->ui_ubanum, &vsbuf, UBA_CANTWAIT);
232:
233: vsb->vsioa.reloc = (int) (vsp->offset.fparm_all
234: + (vsp->vsBuff_ubinfo & 0x3ffff));
235: return(0);
236: }
237:
238: vsclose(dev)
239: dev_t dev;
240: {
241: register struct uba_device *uip = vsdinfo[VSUNIT(dev)];
242: register struct vs_softc *vsp = &vs_softc[VSUNIT(dev)];
243: int s, i;
244: struct vsdevice *vsaddr;
245: struct vsBuffArea *vsb;
246: caddr_t vsBuffpage;
247: int vsBuffnpages;
248:
249: vsaddr = (struct vsdevice *) uip->ui_addr;
250: printM("vsclose csr0=%x, csr1=%x, csr2=%x, csr3=%x, csr4=%x, csr5=%x, csr6=%x, csr7=%x\n",
251: vsaddr->vs_csr0, vsaddr->vs_csr1, vsaddr->vs_csr2, vsaddr->vs_csr3,
252: vsaddr->vs_csr4, vsaddr->vs_csr5, vsaddr->vs_csr6, vsaddr->vs_csr7);
253: vsb = &vsBuff[VSUNIT(dev)];
254: if (vsDebugPrintfs) {
255: printf("vs%d: %d errors, %d unsolicited interrupts",
256: VSUNIT(dev), vsp->stats.errors, vsp->stats.unsolIntr);
257: printf(", %d link errors", vsp->stats.linkErrors);
258: printf(", %d overruns", vsp->stats.overruns);
259: printf(", csr0 %x, csr1 %x", vsaddr->vs_csr0, vsaddr->vs_csr1);
260: printf("\n");
261: }
262:
263: vsp->open = FALSE;
264: vsp->inited = FALSE; /* init on every open */
265: vsp->vs_nextgo.fparm_all = NULL;
266: vsb->vsioa.mbox.bottom = 0;
267: /* release the buffer */
268: if (vsp->vsBuff_ubinfo!=0) {
269: ubarelse(uip->ui_ubanum, &vsp->vsBuff_ubinfo);
270: }
271:
272: #ifdef notdef
273: /* unmap io regs into user address space (assume they don't cross a page) */
274: unmaptouser(vsaddr);
275: /* unmap vsBuff into user address space */
276: vsBuffpage = (caddr_t)((int)vsb & ~PGOFSET);
277: vsBuffnpages = (((int)vsb&PGOFSET) +
278: (NBPG-1)+ sizeof(struct vsBuffArea)) >> PGSHIFT;
279: while (vsBuffnpages>0) {
280: unmaptouser(vsBuffpage);
281: vsBuffpage += NBPG;
282: vsBuffnpages--;
283: }
284: #endif
285: }
286:
287: vsread(dev,uio)
288: dev_t dev;
289: struct uio *uio;
290: {
291: return(-1);
292: }
293:
294: vswrite(dev, uio)
295: dev_t dev;
296: struct uio *uio;
297: {
298: return(-1);
299: }
300:
301: /*ARGSUSED*/
302: vsioctl(dev, cmd, addr, flag)
303: dev_t dev;
304: register caddr_t addr;
305: {
306: register struct uba_device *uip = vsdinfo[VSUNIT(dev)];
307: register struct vs_softc *vsp = &vs_softc[VSUNIT(dev)];
308: register struct vsdevice *vsaddr = (struct vsdevice *) uip->ui_addr;
309: register struct vsBuffArea *vsb = &vsBuff[VSUNIT(dev)];
310: struct vs_fparm vsAddr;
311: int s;
312: int func;
313: int ret;
314:
315: switch(cmd) { /* things that don't need the device */
316: case VSIOWAITGO:
317: /* wait for user I/O operation to complete, then go */
318: s = spl5();
319: if ((ret = vsb->vsioa.status) == 0) {
320: vsp->vs_nextgo.fparm_all = ((struct vs_fparm *) addr)->fparm_all;
321: do {
322: sleep((caddr_t) vsp, VSWAITPRI);
323: } while (vsp->vs_nextgo.fparm_all);
324: ret = vsp->vs_status;
325: } else {
326: vsaddr->vs_pr1 = ((struct vs_fparm *)addr)->fparm_low;
327: vsaddr->vs_pr2 = ((struct vs_fparm *)addr)->fparm_high;
328: vsb->vsioa.status = 0;
329: vsaddr->vs_csr0 &= ~VS_FCN; /* clear bits */
330: vsaddr->vs_csr0 |= (VS_IE | (VS_SEND << VS_FCSHIFT) | VS_GO);
331: }
332: splx(s);
333: if (ret & VS_ERROR)
334: return ((ret & VS_REASON) + 128);
335: return(0);
336:
337: case VSIOUSERWAIT:
338: /* wait for user I/O operation to complete */
339: s = spl5();
340: while (vsb->vsioa.status == 0) {
341: sleep((caddr_t) vsp, VSWAITPRI);
342: }
343: splx(s);
344: return (0);
345:
346: case VSIOGETVER: /* get ROM version */
347: if (!vsp->inited)
348: return(ENODEV);
349: *(int *) addr = vsp->romVersion;
350: return(0);
351:
352: case VSIOGETSTATS: /* get statistics block */
353: *(vsStats *)addr = vsp->stats;
354: return(0);
355:
356: case VSIOGETIOA: /* get io addresses */
357: if (vsp->vsBuff_ubinfo==0) {
358: return(EIO);
359: }
360: *((vsIoAddrAddr *)addr) = &vsb->vsioa;
361: return(0);
362:
363: default: /* a command that could block */
364: if (ret = vsError(vsp))
365: return(ret);
366: break;
367: }
368:
369: switch(cmd) { /* Commands that cause an interrupt */
370: case VSIOINIT: /* initialize device */
371: vsInitDev(dev, FALSE);
372: return(vsError(vsp));
373:
374: case VSIOSTART: /* start microcode */
375: vsAddr.fparm_all = *(caddr_t *)addr;
376: s = spl5();
377: vsaddr->vs_pr1 = vsAddr.fparm_low;
378: vsaddr->vs_pr2 = vsAddr.fparm_high;
379: vsaddr->vs_irr = 0;
380: vsaddr->vs_csr0 &= ~VS_FCN; /* clear bits */
381: vsaddr->vs_csr0 |= (VS_IE | (VS_START << VS_FCSHIFT) | VS_GO);
382: sleep((caddr_t) vsp, VSWAITPRI); /* synchronous */
383: splx(s);
384: return(vsError(vsp));
385:
386: case VSIOABORT: /* abort a command chain */
387: s = spl5();
388: vsaddr->vs_irr = 0;
389: vsaddr->vs_csr0 &= ~VS_FCN;
390: vsaddr->vs_csr0 |= (VS_IE | (VS_ABORT << VS_FCSHIFT) | VS_GO);
391: sleep((caddr_t) vsp, VSWAITPRI);
392: splx(s);
393: return(vsError(vsp));
394:
395: case VSIOPWRUP: /* power-up reset */
396: s = spl5();
397: vsaddr->vs_irr = 0;
398: vsaddr->vs_csr0 &= ~VS_FCN;
399: vsaddr->vs_csr0 |= (VS_IE | (VS_PWRUP << VS_FCSHIFT) | VS_GO);
400: sleep((caddr_t) vsp, VSWAITPRI);
401: splx(s);
402: return(vsError(vsp));
403:
404: case VSIOBBACTL: /* enable/disable BBA */
405: s = spl5();
406: vsaddr->vs_irr = 0;
407: vsaddr->vs_csr0 &= ~VS_FCN;
408: func = *(int *)addr == VSIO_ON ? VS_ENABBA : VS_DISBBA;
409: vsaddr->vs_csr0 |= (VS_IE | (func << VS_FCSHIFT) | VS_GO);
410: sleep((caddr_t) vsp, VSWAITPRI);
411: splx(s);
412: return(vsError(vsp));
413:
414: case VSIOFIBCTL: /* turn the fiber lamp on/off */
415: s = spl5();
416: if (*(int *)addr == VSIO_OFF)
417: vsaddr->vs_csr0 &= ~VS_XMIT_ON;
418: else
419: vsaddr->vs_csr0 |= (VS_IE | VS_XMIT_ON);
420: sleep((caddr_t) vsp, VSWAITPRI);
421: splx(s);
422: return(vsError(vsp));
423:
424: case VSIOFIBRETRY: /* set fiber retries */
425: s = spl5();
426: vsaddr->vs_irr = 0;
427: vsaddr->vs_csr0 &= ~VS_FCN;
428: func = *(int *)addr == VS_FIB_FINITE ? VS_FINITE : VS_INFINITE;
429: vsaddr->vs_csr0 |= (VS_IE | (func << VS_FCSHIFT) | VS_GO);
430: sleep((caddr_t) vsp, VSWAITPRI);
431: splx(s);
432: return(vsError(vsp));
433:
434: case VSIOSYNC: /* get synchronized with device */
435: break;
436:
437: default:
438: return(ENOTTY);
439: }
440:
441: return(0);
442: }
443:
444: vsintr(dev)
445: dev_t dev;
446: {
447: register struct vsdevice *vsaddr;
448: register struct vs_softc *vsp;
449: register vsEvent *vep;
450: struct uba_device *uip;
451: register struct vsBuffArea *vsb;
452: int i;
453: vsCursor cur;
454:
455: if (VSUNIT(dev) >= NVS || (uip = vsdinfo[VSUNIT(dev)]) == 0
456: || uip->ui_alive == 0) {
457: printI("vs%d stray interrupt\n", VSUNIT(dev));
458: return;
459: }
460:
461: vsaddr = (struct vsdevice *) uip->ui_addr;
462: vsp = &vs_softc[VSUNIT(dev)];
463: vsb = &vsBuff[VSUNIT(dev)];
464: #ifdef notdef
465: printM("vsintr csr0=%x, csr1=%x, csr2=%x, csr3=%x, csr4=%x, csr5=%x, csr6=%x, csr7=%x\n",
466: vsaddr->vs_csr0, vsaddr->vs_csr1, vsaddr->vs_csr2, vsaddr->vs_csr3,
467: vsaddr->vs_csr4, vsaddr->vs_csr5, vsaddr->vs_csr6, vsaddr->vs_csr7);
468:
469: printI("vs%dintr ", VSUNIT(dev));
470: #endif
471:
472: /*
473: * get the information out of the soft registers
474: */
475:
476: vsp->irr.intr_reg = vsaddr->vs_irr;
477: vsp->krr.kbd_reg = vsaddr->vs_krr;
478: vsp->pr.fparm_low = vsaddr->vs_pr1;
479: vsp->pr.fparm_high = vsaddr->vs_pr2;
480: cur.x = vsaddr->vs_cxr;
481: cur.y = vsaddr->vs_cyr;
482: vsp->csr.csr_reg = vsaddr->vs_csr0;
483:
484: if (vsp->irr.intr_reason)
485: vsaddr->vs_irr = 0; /* clear int reason, if any */
486:
487: vsaddr->vs_csr0 &= ~VS_OWN; /* clear owner bit */
488:
489: if (vsp->csr.csr_linkTran) {
490: vsaddr->vs_csr0 &= ~VS_LNK_TRNS; /* clear the bit */
491: printI("link transition: ");
492: if (vsp->csr.csr_linkErr)
493: vsp->stats.linkErrors++;
494:
495: if (vsp->csr.csr_linkAvail == vsp->linkAvail) { /* flash */
496: vsp->stats.flashes++;
497: printI("flash\n");
498: } else if (!vsp->csr.csr_linkAvail && vsp->linkAvail) { /* on -> off */
499: vsp->stats.douses++;
500: printI("douse\n");
501: vsp->inited = FALSE;
502: if (vsp->open && vsp->pgrp)
503: gsignal(vsp->pgrp, SIGHUP);
504: wakeup((caddr_t) vsp);
505: } else { /* off -> on */
506: vsp->stats.ignites++;
507: printI("ignite\n");
508: wakeup((caddr_t) vsp);
509: }
510:
511: i = 200;
512: while ((vsaddr->vs_csr0 & VS_LNK_TRNS) && i)
513: i--;
514: if (i == 0) { /* bit stuck */
515: printI("vs%d: Link Transition bit stuck\n", VSUNIT(dev));
516: vsp->inited = FALSE;
517: if (vsp->open && vsp->pgrp)
518: gsignal(vsp->pgrp, SIGHUP);
519: vsaddr->vs_csr0 &= ~VS_XMIT_ON;
520: vsp->csr.csr_linkAvail = FALSE;
521: }
522:
523: vsp->linkAvail = vsp->csr.csr_linkAvail;
524:
525: return;
526: }
527:
528: if (vsp->irr.intr_error) {
529: printI("error 0x%x\n", vsp->irr.intr_reg&0xffff);
530: vsp->stats.errors++;
531: /* set status and wake up user if necessary */
532: if (vsp->vs_nextgo.fparm_all) {
533: vsp->vs_status = vsp->irr.intr_reg;
534: vsaddr->vs_pr1 = vsp->vs_nextgo.fparm_low;
535: vsaddr->vs_pr2 = vsp->vs_nextgo.fparm_high;
536: vsp->vs_nextgo.fparm_all = NULL;
537: vsaddr->vs_csr0 &= ~VS_FCN; /* clear bits */
538: vsaddr->vs_csr0 |= (VS_IE | (VS_SEND << VS_FCSHIFT) | VS_GO);
539: } else
540: vsb->vsioa.status = vsp->irr.intr_reg;
541: wakeup((caddr_t) vsp);
542: return;
543: }
544:
545: #ifdef notdef
546: printI("reason is %b\n", vsp->irr.intr_reason, VSIRR_BITS);
547: #endif
548: switch(vsp->irr.intr_reason) {
549: case VS_INT_CD: /* command done */
550: /* set status and start a new command if necessary */
551: if (vsp->vs_nextgo.fparm_all) {
552: vsp->vs_status = vsp->irr.intr_reg;
553: vsaddr->vs_pr1 = vsp->vs_nextgo.fparm_low;
554: vsaddr->vs_pr2 = vsp->vs_nextgo.fparm_high;
555: vsp->vs_nextgo.fparm_all = NULL;
556: vsaddr->vs_csr0 &= ~VS_FCN; /* clear bits */
557: vsaddr->vs_csr0 |= (VS_IE | (VS_SEND << VS_FCSHIFT) | VS_GO);
558: } else
559: vsb->vsioa.status = vsp->irr.intr_reg;
560: break;
561:
562: case VS_INT_MM: /* mouse moved */
563:
564: vsb->vsioa.mouse = cur;
565:
566: if (!vsp->open)
567: return; /* ignore on closed device */
568:
569: /* no event if inside box */
570: if (cur.y < vsb->vsioa.mbox.bottom &&
571: cur.y >= vsb->vsioa.mbox.top &&
572: cur.x < vsb->vsioa.mbox.right &&
573: cur.x >= vsb->vsioa.mbox.left)
574: return;
575:
576: /* trash box */
577: vsb->vsioa.mbox.bottom = 0;
578:
579: if (EVROUND(vsb->vsioa.itail+1) == vsb->vsioa.ihead)
580: return;
581: i = EVROUND(vsb->vsioa.itail-1);
582: if ((vsb->vsioa.itail != vsb->vsioa.ihead) &&
583: (i != vsb->vsioa.ihead)) {
584: vep = &vsb->ibuff[i];
585: if (vep->vse_type == VSE_MMOTION) {
586: vep->vse_x = cur.x;
587: vep->vse_y = cur.y;
588: vep->vse_time = mfpr(TODR);
589: return;
590: }
591: }
592: /* put event into queue and do select */
593: vep = &vsb->ibuff[vsb->vsioa.itail];
594: vep->vse_type = VSE_MMOTION;
595: vep->vse_x = cur.x;
596: vep->vse_y = cur.y;
597: vep->vse_time = mfpr(TODR);
598: vsb->vsioa.itail = EVROUND(vsb->vsioa.itail+1);
599: if (vsp->rsel) {
600: selwakeup(vsp->rsel, 0);
601: vsp->rsel = 0;
602: }
603: break;
604:
605: case VS_INT_BE: /* button event */
606: if (!vsp->open)
607: return; /* ignore on closed device */
608:
609: if (vsp->krr.kbd_device == VSE_MOUSE) {
610: vsb->vsioa.mouse.x = cur.x;
611: vsb->vsioa.mouse.y = cur.y;
612: }
613: /* check for room in the queue */
614: if ((i = EVROUND(vsb->vsioa.itail+1)) == vsb->vsioa.ihead)
615: return;
616: /* put event into queue and do select */
617: vep = &vsb->ibuff[vsb->vsioa.itail];
618: vep->vse_type = VSE_BUTTON;
619: vep->vse_key = vsp->krr.kbd_key;
620: vep->vse_direction = vsp->krr.kbd_transition;
621: vep->vse_device = vsp->krr.kbd_device;
622: vep->vse_time = mfpr(TODR);
623: vep->vse_x = vsb->vsioa.mouse.x;
624: vep->vse_y = vsb->vsioa.mouse.y;
625: vsb->vsioa.itail = i;
626: if (vsp->rsel) {
627: selwakeup(vsp->rsel, 0);
628: vsp->rsel = 0;
629: }
630: break;
631:
632: case VS_INT_TM: /* tablet moved */
633: if (!vsp->open)
634: return; /* ignore on closed device */
635:
636: if (EVROUND(vsb->vsioa.itail+1) == vsb->vsioa.ihead)
637: return;
638: i = EVROUND(vsb->vsioa.itail-1);
639: if ((vsb->vsioa.itail != vsb->vsioa.ihead) &&
640: (i != vsb->vsioa.ihead)) {
641: vep = &vsb->ibuff[i];
642: if (vep->vse_type == VSE_TMOTION) {
643: vep->vse_x = cur.x;
644: vep->vse_y = cur.y;
645: vep->vse_time = mfpr(TODR);
646: return;
647: }
648: }
649: /* put event into queue and do select */
650: vep = &vsb->ibuff[vsb->vsioa.itail];
651: vep->vse_type = VSE_TMOTION;
652: vep->vse_x = cur.x;
653: vep->vse_y = cur.y;
654: vep->vse_time = mfpr(TODR);
655: vsb->vsioa.itail = EVROUND(vsb->vsioa.itail+1);
656: if (vsp->rsel) {
657: selwakeup(vsp->rsel, 0);
658: vsp->rsel = 0;
659: }
660: break;
661:
662: case VS_INT_US: /* unsolicited */
663: vsp->stats.unsolIntr++;
664: return;
665:
666: case VS_INT_ID: /* Initialization done */
667: /* save offset from device */
668: vsp->offset.fparm_all = vsp->pr.fparm_all;
669: /* save rom version */
670: vsp->romVersion = cur.x;
671: vsp->inited = TRUE;
672: break;
673:
674: case VS_INT_SE: /* ucode started */
675: break;
676:
677: case VS_INT_PWR: /* power up complete */
678: /* save rom version */
679: vsp->romVersion = cur.x;
680: vsp->inited = FALSE;
681: if (vsp->open && vsp->pgrp)
682: gsignal(vsp->pgrp, SIGHUP);
683: break;
684:
685: default:
686: printI("vs%d: unknown interrupt %b\n", VSUNIT(dev),
687: vsp->irr.intr_reason, VSIRR_BITS);
688: return;
689: }
690: wakeup((caddr_t) vsp);
691: }
692:
693: vsreset(uban)
694: int uban;
695: {
696: register int i;
697: register struct uba_device *uip;
698: register struct vs_softc *vsp = vs_softc;
699:
700: for (i = 0; i < NVS; i++, vsp++) {
701: if ((uip = vsdinfo[i]) == 0 || uip->ui_alive == 0 ||
702: uip->ui_ubanum != uban || vsp->open == 0)
703: continue;
704: printf(" vs%d", i);
705: vsp->inited = FALSE;
706: if (vsp->open && vsp->pgrp)
707: gsignal(vsp->pgrp, SIGHUP);
708: }
709: }
710:
711: vsselect(dev, rw)
712: dev_t dev;
713: {
714: register struct vsBuffArea *vsb = &vsBuff[VSUNIT(dev)];
715: int s = spl5();
716:
717: switch(rw) {
718: case FREAD:
719: if (vsb->vsioa.ihead != vsb->vsioa.itail) {
720: splx(s);
721: return(1);
722: }
723: vs_softc[VSUNIT(dev)].rsel = u.u_procp;
724: splx(s);
725: return(0);
726:
727: case FWRITE:
728: splx(s);
729: return(EACCES);
730: }
731: }
732:
733: /*
734: * Initialize VS100 or SBO.
735: * Set XMITON. VS100 will respond with link available. SBO won't, so
736: * don't wait forever; assume everything is OK and warn user.
737: */
738:
739: vsInitFiber(dev)
740: dev_t dev;
741: {
742: struct vsdevice *vsaddr = (struct vsdevice *) vsdinfo[VSUNIT(dev)]->ui_addr;
743: register struct vs_softc *vsp = &vs_softc[VSUNIT(dev)];
744: int s;
745: #ifdef VSSBO
746: int vsFiberNudge();
747:
748: timeout(vsFiberNudge, (caddr_t) dev, 2*hz);
749: #endif
750: s = spl5();
751: vsaddr->vs_csr0 |= (VS_IE | VS_XMIT_ON); /* turn link on */
752: sleep((caddr_t) vsp, VSWAITPRI);
753: splx(s);
754: #ifdef VSSBO
755: if (!vsp->linkAvail) {
756: uprintf("\007This had better be a vs125!\n");
757: printf("vs%d must be a vs125\n", VSUNIT(dev));
758: vsp->linkAvail = TRUE;
759: }
760: #endif
761: }
762:
763: #ifdef VSSBO
764: vsFiberNudge(dev)
765: dev_t dev;
766: {
767: struct vs_softc *vsp = &vs_softc[VSUNIT(dev)];
768:
769: if (!vsp->linkAvail)
770: wakeup((caddr_t) vsp);
771: }
772: #endif VSSBO
773:
774: vsInitDev(dev, retry)
775: dev_t dev;
776: int retry;
777: {
778: register struct vsdevice *vsaddr;
779: register struct vs_softc *vsp;
780: int s;
781: int vsInitNudge();
782:
783: vsaddr = (struct vsdevice *) vsdinfo[VSUNIT(dev)]->ui_addr;
784: vsp = &vs_softc[VSUNIT(dev)];
785:
786: if (!vsp->linkAvail)
787: vsInitFiber(dev);
788: while (1) {
789: if (retry)
790: timeout(vsInitNudge, (caddr_t) dev, 10*hz);
791: s = spl5();
792: vsaddr->vs_irr = 0;
793: vsaddr->vs_csr0 &= ~VS_FCN;
794: vsaddr->vs_csr0 |= (VS_IE | (VS_INIT << VS_FCSHIFT) | VS_GO);
795: sleep((caddr_t) vsp, VSWAITPRI);
796: splx(s);
797: if (vsp->inited)
798: break;
799: printM("vs%d: VS_INIT fails\n", VSUNIT(dev));
800: uprintf("vsInitDev %x %x\n",vsaddr->vs_csr0, vsaddr->vs_csr1);
801: }
802: }
803:
804: vsInitNudge(dev)
805: dev_t dev;
806: {
807: struct vs_softc *vsp = &vs_softc[VSUNIT(dev)];
808:
809: if (!vsp->inited)
810: wakeup((caddr_t) vsp);
811: }
812:
813: vsError(vsp)
814: register struct vs_softc *vsp;
815: {
816: if (vsp->irr.intr_error) {
817: register int ret = vsp->irr.intr_reg;
818:
819: printD("\treturning 0x%x\n", ret);
820: vsp->irr.intr_reg = 0;
821: return(ret+128);
822: }
823: return(0);
824: }
825: #endif
826:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.