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