![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to grf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / hpdev|
Return to grf.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hpdev |
1.1 root 1: /*
2: * Copyright (c) 1988 University of Utah.
3: * Copyright (c) 1990 The Regents of the University of California.
4: * All rights reserved.
5: *
6: * This code is derived from software contributed to Berkeley by
7: * the Systems Programming Group of the University of Utah Computer
8: * Science Department.
9: *
10: * Redistribution is only permitted until one year after the first shipment
11: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
12: * binary forms are permitted provided that: (1) source distributions retain
13: * this entire copyright notice and comment, and (2) distributions including
14: * binaries display the following acknowledgement: This product includes
15: * software developed by the University of California, Berkeley and its
16: * contributors'' in the documentation or other materials provided with the
17: * distribution and in all advertising materials mentioning features or use
18: * of this software. Neither the name of the University nor the names of
19: * its contributors may be used to endorse or promote products derived from
20: * this software without specific prior written permission.
21: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
22: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
23: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
24: *
25: * from: Utah $Hdr: grf.c 1.28 89/08/14$
26: *
27: * @(#)grf.c 7.4 (Berkeley) 6/22/90
28: */
29:
30: /*
31: * Graphics display driver for the HP300.
32: * This is the hardware-independent portion of the driver.
33: * Hardware access is through the grfdev routines below.
34: */
35:
36: #include "grf.h"
37: #if NGRF > 0
38:
39: #include "param.h"
40: #include "user.h"
41: #include "proc.h"
42: #include "ioctl.h"
43: #include "file.h"
44: #include "mapmem.h"
45: #include "malloc.h"
46:
47: #include "device.h"
48: #include "grfioctl.h"
49: #include "grfvar.h"
50:
51: #include "machine/cpu.h"
52:
53: #ifdef HPUXCOMPAT
54: #include "../hpux/hpux.h"
55: #endif
56:
57: #include "ite.h"
58: #if NITE == 0
59: #define iteon(u,f)
60: #define iteoff(u,f)
61: #endif
62:
63: int grfprobe();
64: int tc_init(), tc_mode();
65: int gb_init(), gb_mode();
66: int rb_init(), rb_mode();
67: int dv_init(), dv_mode();
68:
69: struct grfdev grfdev[] = {
70: GID_TOPCAT, GRFBOBCAT, tc_init, tc_mode,
71: "topcat",
72: GID_GATORBOX, GRFGATOR, gb_init, gb_mode,
73: "gatorbox",
74: GID_RENAISSANCE,GRFRBOX, rb_init, rb_mode,
75: "renaissance",
76: GID_LRCATSEYE, GRFCATSEYE, tc_init, tc_mode,
77: "lo-res catseye",
78: GID_HRCCATSEYE, GRFCATSEYE, tc_init, tc_mode,
79: "hi-res catseye",
80: GID_HRMCATSEYE, GRFCATSEYE, tc_init, tc_mode,
81: "hi-res catseye",
82: GID_DAVINCI, GRFDAVINCI, dv_init, dv_mode,
83: "davinci",
84: };
85: int ngrfdev = sizeof(grfdev) / sizeof(grfdev[0]);
86:
87: struct driver grfdriver = { grfprobe, "grf" };
88: struct grf_softc grf_softc[NGRF];
89:
90: #ifdef MAPMEM
91: int grfexit();
92: struct mapmemops grfops = { (int (*)())0, (int (*)())0, grfexit, grfexit };
93: #ifdef HPUXCOMPAT
94: struct mapmemops grflckops = { (int (*)())0, (int (*)())0, grfexit, grfexit };
95: struct mapmemops grfiomops = { (int (*)())0, (int (*)())0, grfexit, grfexit };
96: #endif
97: #endif
98:
99: #ifdef DEBUG
100: int grfdebug = 0;
101: #define GDB_DEVNO 0x01
102: #define GDB_MMAP 0x02
103: #define GDB_IOMAP 0x04
104: #define GDB_LOCK 0x08
105: #endif
106:
107: /*
108: * XXX: called from ite console init routine.
109: * Does just what configure will do later but without printing anything.
110: */
111: grfconfig()
112: {
113: register caddr_t addr;
114: register struct hp_hw *hw;
115: register struct hp_device *hd, *nhd;
116:
117: for (hw = sc_table; hw->hw_type; hw++) {
118: if (hw->hw_type != BITMAP)
119: continue;
120: /*
121: * Found one, now match up with a logical unit number
122: */
123: nhd = NULL;
124: addr = hw->hw_addr;
125: for (hd = hp_dinit; hd->hp_driver; hd++) {
126: if (hd->hp_driver != &grfdriver || hd->hp_alive)
127: continue;
128: /*
129: * Wildcarded. If first, remember as possible match.
130: */
131: if (hd->hp_addr == NULL) {
132: if (nhd == NULL)
133: nhd = hd;
134: continue;
135: }
136: /*
137: * Not wildcarded.
138: * If exact match done searching, else keep looking.
139: */
140: if ((caddr_t)sctoaddr(hd->hp_addr) == addr) {
141: nhd = hd;
142: break;
143: }
144: }
145: /*
146: * Found a match, initialize
147: */
148: if (nhd && grfinit(addr, nhd->hp_unit)) {
149: nhd->hp_addr = addr;
150: }
151: }
152: }
153:
154: /*
155: * Normal init routine called by configure() code
156: */
157: grfprobe(hd)
158: struct hp_device *hd;
159: {
160: struct grf_softc *gp = &grf_softc[hd->hp_unit];
161:
162: if ((gp->g_flags & GF_ALIVE) == 0 &&
163: !grfinit(hd->hp_addr, hd->hp_unit))
164: return(0);
165: printf("grf%d: %d x %d ", hd->hp_unit,
166: gp->g_display.gd_dwidth, gp->g_display.gd_dheight);
167: if (gp->g_display.gd_colors == 2)
168: printf("monochrome");
169: else
170: printf("%d color", gp->g_display.gd_colors);
171: printf(" %s display\n", grfdev[gp->g_type].gd_desc);
172: return(1);
173: }
174:
175: grfinit(addr, unit)
176: caddr_t addr;
177: {
178: struct grf_softc *gp = &grf_softc[unit];
179: struct grfreg *gr;
180: register struct grfdev *gd;
181:
182: gr = (struct grfreg *) addr;
183: if (gr->gr_id != GRFHWID)
184: return(0);
185: for (gd = grfdev; gd < &grfdev[ngrfdev]; gd++)
186: if (gd->gd_hardid == gr->gr_id2)
187: break;
188: if (gd < &grfdev[ngrfdev] && (*gd->gd_init)(gp, addr)) {
189: gp->g_display.gd_id = gd->gd_softid;
190: gp->g_type = gd - grfdev;
191: gp->g_flags = GF_ALIVE;
192: return(1);
193: }
194: return(0);
195: }
196:
197: /*ARGSUSED*/
198: grfopen(dev, flags)
199: dev_t dev;
200: {
201: int unit = GRFUNIT(dev);
202: register struct grf_softc *gp = &grf_softc[unit];
203: int error = 0;
204:
205: if (unit >= NGRF || (gp->g_flags & GF_ALIVE) == 0)
206: return(ENXIO);
207: if ((gp->g_flags & (GF_OPEN|GF_EXCLUDE)) == (GF_OPEN|GF_EXCLUDE))
208: return(EBUSY);
209: #ifdef HPUXCOMPAT
210: /*
211: * XXX: cannot handle both HPUX and BSD processes at the same time
212: */
213: if (u.u_procp->p_flag & SHPUX)
214: if (gp->g_flags & GF_BSDOPEN)
215: return(EBUSY);
216: else
217: gp->g_flags |= GF_HPUXOPEN;
218: else
219: if (gp->g_flags & GF_HPUXOPEN)
220: return(EBUSY);
221: else
222: gp->g_flags |= GF_BSDOPEN;
223: #endif
224: /*
225: * First open.
226: * XXX: always put in graphics mode.
227: */
228: error = 0;
229: if ((gp->g_flags & GF_OPEN) == 0) {
230: gp->g_flags |= GF_OPEN;
231: error = grfon(dev);
232: }
233: return(error);
234: }
235:
236: /*ARGSUSED*/
237: grfclose(dev, flags)
238: dev_t dev;
239: {
240: register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
241:
242: (void) grfoff(dev);
243: (void) grfunlock(gp);
244: gp->g_flags &= GF_ALIVE;
245: return(0);
246: }
247:
248: /*ARGSUSED*/
249: grfioctl(dev, cmd, data, flag)
250: dev_t dev;
251: caddr_t data;
252: {
253: register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
254: int error;
255:
256: #ifdef HPUXCOMPAT
257: if (u.u_procp->p_flag & SHPUX)
258: return(hpuxgrfioctl(dev, cmd, data, flag));
259: #endif
260: error = 0;
261: switch (cmd) {
262:
263: /* XXX: compatibility hack */
264: case OGRFIOCGINFO:
265: bcopy((caddr_t)&gp->g_display, data, sizeof(struct ogrfinfo));
266: break;
267:
268: case GRFIOCGINFO:
269: bcopy((caddr_t)&gp->g_display, data, sizeof(struct grfinfo));
270: break;
271:
272: case GRFIOCON:
273: error = grfon(dev);
274: break;
275:
276: case GRFIOCOFF:
277: error = grfoff(dev);
278: break;
279:
280: #ifdef MAPMEM
281: case GRFIOCMAP:
282: error = grfmmap(dev, (caddr_t *)data);
283: break;
284:
285: case GRFIOCUNMAP:
286: error = grfunmmap(dev, *(caddr_t *)data);
287: break;
288: #endif
289:
290: default:
291: error = EINVAL;
292: break;
293:
294: }
295: return(error);
296: }
297:
298: /*ARGSUSED*/
299: grfselect(dev, rw)
300: dev_t dev;
301: {
302: if (rw == FREAD)
303: return(0);
304: return(1);
305: }
306:
307: grflock(gp, block)
308: register struct grf_softc *gp;
309: int block;
310: {
311: struct proc *p = u.u_procp; /* XXX */
312: int error;
313: extern char devioc[];
314:
315: #ifdef DEBUG
316: if (grfdebug & GDB_LOCK)
317: printf("grflock(%d): dev %x flags %x lockpid %x\n",
318: p->p_pid, gp-grf_softc, gp->g_flags,
319: gp->g_lockp ? gp->g_lockp->p_pid : -1);
320: #endif
321: #ifdef HPUXCOMPAT
322: if (gp->g_pid) {
323: #ifdef DEBUG
324: if (grfdebug & GDB_LOCK)
325: printf(" lock[0] %d lockslot %d lock[lockslot] %d\n",
326: gp->g_locks[0], gp->g_lockpslot,
327: gp->g_locks[gp->g_lockpslot]);
328: #endif
329: gp->g_locks[0] = 0;
330: if (gp->g_locks[gp->g_lockpslot] == 0) {
331: gp->g_lockp = NULL;
332: gp->g_lockpslot = 0;
333: }
334: }
335: #endif
336: if (gp->g_lockp) {
337: if (gp->g_lockp == p)
338: return(EBUSY);
339: if (!block)
340: return(EAGAIN);
341: do {
342: gp->g_flags |= GF_WANTED;
343: if (error = tsleep((caddr_t)&gp->g_flags,
344: (PZERO+1) | PCATCH, devioc, 0))
345: return (error);
346: } while (gp->g_lockp);
347: }
348: gp->g_lockp = p;
349: #ifdef HPUXCOMPAT
350: if (gp->g_pid) {
351: int slot = grffindpid(gp);
352: #ifdef DEBUG
353: if (grfdebug & GDB_LOCK)
354: printf(" slot %d\n", slot);
355: #endif
356: gp->g_lockpslot = gp->g_locks[0] = slot;
357: gp->g_locks[slot] = 1;
358: }
359: #endif
360: return(0);
361: }
362:
363: grfunlock(gp)
364: register struct grf_softc *gp;
365: {
366: #ifdef DEBUG
367: if (grfdebug & GDB_LOCK)
368: printf("grfunlock(%d): dev %x flags %x lockpid %d\n",
369: u.u_procp->p_pid, gp-grf_softc, gp->g_flags,
370: gp->g_lockp ? gp->g_lockp->p_pid : -1);
371: #endif
372: if (gp->g_lockp != u.u_procp)
373: return(EBUSY);
374: #ifdef HPUXCOMPAT
375: if (gp->g_pid) {
376: #ifdef DEBUG
377: if (grfdebug & GDB_LOCK)
378: printf(" lock[0] %d lockslot %d lock[lockslot] %d\n",
379: gp->g_locks[0], gp->g_lockpslot,
380: gp->g_locks[gp->g_lockpslot]);
381: #endif
382: gp->g_locks[gp->g_lockpslot] = gp->g_locks[0] = 0;
383: gp->g_lockpslot = 0;
384: }
385: #endif
386: if (gp->g_flags & GF_WANTED) {
387: wakeup((caddr_t)&gp->g_flags);
388: gp->g_flags &= ~GF_WANTED;
389: }
390: gp->g_lockp = NULL;
391: return(0);
392: }
393:
394: /*ARGSUSED*/
395: grfmap(dev, off, prot)
396: dev_t dev;
397: {
398: return(grfaddr(&grf_softc[GRFUNIT(dev)], off));
399: }
400:
401: #ifdef HPUXCOMPAT
402:
403: /*ARGSUSED*/
404: hpuxgrfioctl(dev, cmd, data, flag)
405: dev_t dev;
406: caddr_t data;
407: {
408: register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
409: int error;
410:
411: error = 0;
412: switch (cmd) {
413:
414: case GCID:
415: *(int *)data = gp->g_display.gd_id;
416: break;
417:
418: case GCON:
419: error = grfon(dev);
420: break;
421:
422: case GCOFF:
423: error = grfoff(dev);
424: break;
425:
426: case GCLOCK:
427: error = grflock(gp, 1);
428: break;
429:
430: case GCUNLOCK:
431: error = grfunlock(gp);
432: break;
433:
434: case GCAON:
435: case GCAOFF:
436: break;
437:
438: /* GCSTATIC is implied by our implementation */
439: case GCSTATIC_CMAP:
440: case GCVARIABLE_CMAP:
441: break;
442:
443: #ifdef MAPMEM
444: /* map in control regs and frame buffer */
445: case GCMAP:
446: error = grfmmap(dev, (caddr_t *)data);
447: break;
448:
449: case GCUNMAP:
450: error = grfunmmap(dev, *(caddr_t *)data);
451: /* XXX: HP-UX uses GCUNMAP to get rid of GCSLOT memory */
452: if (error)
453: error = grflckunmmap(dev, *(caddr_t *)data);
454: break;
455:
456: case GCSLOT:
457: {
458: struct grf_slot *sp = (struct grf_slot *)data;
459:
460: sp->slot = grffindpid(gp);
461: if (sp->slot)
462: error = grflckmmap(dev, (caddr_t *)&sp->addr);
463: else
464: error = EINVAL; /* XXX */
465: break;
466: }
467:
468: /*
469: * XXX: only used right now to map in rbox control registers
470: * Will be replaced in the future with a real IOMAP interface.
471: */
472: case IOMAPMAP:
473: error = iommap(dev, (caddr_t *)data);
474: #if 0
475: /*
476: * It may not be worth kludging this (using p_devtmp) to
477: * make this work. It was an undocumented side-effect
478: * in HP-UX that the mapped address was the return value
479: * of the ioctl. The only thing I remember that counted
480: * on this behavior was the rbox X10 server.
481: */
482: if (!error)
483: u.u_r.r_val1 = *(int *)data; /* XXX: this sux */
484: #endif
485: break;
486:
487: case IOMAPUNMAP:
488: error = iounmmap(dev, *(caddr_t *)data);
489: break;
490: #endif
491:
492: default:
493: error = EINVAL;
494: break;
495: }
496: return(error);
497: }
498:
499: #endif
500:
501: grfon(dev)
502: dev_t dev;
503: {
504: int unit = GRFUNIT(dev);
505: struct grf_softc *gp = &grf_softc[unit];
506:
507: /*
508: * XXX: iteoff call relies on devices being in same order
509: * as ITEs and the fact that iteoff only uses the minor part
510: * of the dev arg.
511: */
512: iteoff(unit, 3);
513: return((*grfdev[gp->g_type].gd_mode)
514: (gp, (dev&GRFOVDEV) ? GM_GRFOVON : GM_GRFON));
515: }
516:
517: grfoff(dev)
518: dev_t dev;
519: {
520: int unit = GRFUNIT(dev);
521: struct grf_softc *gp = &grf_softc[unit];
522: int error;
523:
524: #ifdef MAPMEM
525: (void) grfunmmap(dev, (caddr_t)0);
526: #endif
527: error = (*grfdev[gp->g_type].gd_mode)
528: (gp, (dev&GRFOVDEV) ? GM_GRFOVOFF : GM_GRFOFF);
529: /* XXX: see comment for iteoff above */
530: iteon(unit, 2);
531: return(error);
532: }
533:
534: grfaddr(gp, off)
535: struct grf_softc *gp;
536: register int off;
537: {
538: #ifdef MAPMEM
539: register struct grfinfo *gi = &gp->g_display;
540:
541: /* control registers */
542: if (off >= 0 && off < gi->gd_regsize)
543: return(((u_int)gi->gd_regaddr + off) >> PGSHIFT);
544:
545: /* frame buffer */
546: if (off >= gi->gd_regsize && off < gi->gd_regsize+gi->gd_fbsize) {
547: off -= gi->gd_regsize;
548: return(((u_int)gi->gd_fbaddr + off) >> PGSHIFT);
549: }
550: #endif
551: /* bogus */
552: return(-1);
553: }
554:
555: #ifdef HPUXCOMPAT
556: /*
557: * Convert a BSD style minor devno to HPUX style.
558: * We cannot just create HPUX style nodes as they require 24 bits
559: * of minor device number and we only have 8.
560: * XXX: This may give the wrong result for remote stats of other
561: * machines where device 10 exists.
562: */
563: grfdevno(dev)
564: dev_t dev;
565: {
566: int unit = GRFUNIT(dev);
567: struct grf_softc *gp = &grf_softc[unit];
568: int newdev;
569:
570: if (unit >= NGRF || (gp->g_flags&GF_ALIVE) == 0)
571: return(bsdtohpuxdev(dev));
572: /* magic major number */
573: newdev = 12 << 24;
574: /* now construct minor number */
575: #if defined(HP360) || defined(HP370)
576: if (gp->g_display.gd_regaddr == (caddr_t)DIOIIBASE)
577: newdev |= 0x840200;
578: else
579: #endif
580: if (gp->g_display.gd_regaddr != (caddr_t)GRFIADDR)
581: newdev |= ((u_int)gp->g_display.gd_regaddr-EXTIOBASE) | 0x200;
582: if (dev & GRFIMDEV)
583: newdev |= 0x02;
584: else if (dev & GRFOVDEV)
585: newdev |= 0x01;
586: #ifdef DEBUG
587: if (grfdebug & GDB_DEVNO)
588: printf("grfdevno: dev %x newdev %x\n", dev, newdev);
589: #endif
590: return(newdev);
591: }
592: #endif
593:
594: #ifdef MAPMEM
595: grfmapin(mp, off)
596: struct mapmem *mp;
597: {
598: return(grfaddr(&grf_softc[GRFUNIT(mp->mm_id)], off));
599: }
600:
601: grfmmap(dev, addrp)
602: dev_t dev;
603: caddr_t *addrp;
604: {
605: struct proc *p = u.u_procp; /* XXX */
606: struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
607: struct mapmem *mp;
608: int len, error, grfmapin();
609:
610: #ifdef DEBUG
611: if (grfdebug & GDB_MMAP)
612: printf("grfmmap(%d): addr %x\n", p->p_pid, *addrp);
613: #endif
614: len = gp->g_display.gd_regsize + gp->g_display.gd_fbsize;
615: error = mmalloc(p, minor(dev), addrp, len, MM_RW|MM_CI|MM_NOCORE,
616: &grfops, &mp);
617: if (error == 0)
618: if (error = mmmapin(p, mp, grfmapin))
619: (void) mmfree(p, mp);
620: return(error);
621: }
622:
623: grfunmmap(dev, addr)
624: dev_t dev;
625: caddr_t addr;
626: {
627: register struct mapmem *mp, **mpp;
628: int found, unit = minor(dev);
629:
630: #ifdef DEBUG
631: if (grfdebug & GDB_MMAP)
632: printf("grfunmmap(%d): id %d addr %x\n",
633: u.u_procp->p_pid, unit, addr);
634: #endif
635: found = 0;
636: mpp = &u.u_mmap;
637: for (mp = *mpp; mp; mp = *mpp) {
638: if (mp->mm_ops != &grfops || mp->mm_id != unit) {
639: mpp = &mp->mm_next;
640: continue;
641: }
642: if (addr &&
643: (addr < mp->mm_uva || addr >= mp->mm_uva+mp->mm_size)) {
644: mpp = &mp->mm_next;
645: continue;
646: }
647: (void) grfexit(mp);
648: found++;
649: }
650: return(found ? 0 : EINVAL);
651: }
652:
653: grfexit(mp)
654: struct mapmem *mp;
655: {
656: struct proc *p = u.u_procp; /* XXX */
657: struct grf_softc *gp = &grf_softc[GRFUNIT(mp->mm_id)];
658:
659: #ifdef DEBUG
660: if (grfdebug & GDB_MMAP)
661: printf("grfexit(%d): id %d %x@%x\n",
662: p->p_pid, mp->mm_id, mp->mm_size, mp->mm_uva);
663: #endif
664: (void) grfunlock(gp);
665: #ifdef HPUXCOMPAT
666: grfrmpid(gp);
667: #endif
668: mmmapout(p, mp);
669: return(mmfree(p, mp));
670: }
671:
672: #ifdef HPUXCOMPAT
673: iommap(dev, addrp)
674: dev_t dev;
675: caddr_t *addrp;
676: {
677: struct proc *p = u.u_procp; /* XXX */
678: struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
679: struct mapmem *mp;
680: int len, error, grfmapin();
681:
682: #ifdef DEBUG
683: if (grfdebug & (GDB_MMAP|GDB_IOMAP))
684: printf("iommap(%d): addr %x\n", p->p_pid, *addrp);
685: #endif
686: len = gp->g_display.gd_regsize;
687: error = mmalloc(p, minor(dev), addrp, len, MM_RW|MM_CI|MM_NOCORE,
688: &grfiomops, &mp);
689: if (error == 0)
690: if (error = mmmapin(p, mp, grfmapin))
691: (void) mmfree(p, mp);
692: return(error);
693: }
694:
695: iounmmap(dev, addr)
696: dev_t dev;
697: caddr_t addr;
698: {
699: struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
700: register struct mapmem *mp, **mpp;
701: int found, len, unit = minor(dev);
702:
703: #ifdef DEBUG
704: if (grfdebug & (GDB_MMAP|GDB_IOMAP))
705: printf("iounmmap(%d): id %d addr %x\n",
706: u.u_procp->p_pid, unit, addr);
707: #endif
708: found = 0;
709: len = gp->g_display.gd_regsize;
710: mpp = &u.u_mmap;
711: for (mp = *mpp; mp; mp = *mpp) {
712: if (mp->mm_ops != &grfiomops || mp->mm_id != unit) {
713: mpp = &mp->mm_next;
714: continue;
715: }
716: if (addr &&
717: (addr < mp->mm_uva || addr >= mp->mm_uva+mp->mm_size ||
718: len != mp->mm_size)) {
719: mpp = &mp->mm_next;
720: continue;
721: }
722: (void) grfexit(mp);
723: found++;
724: }
725: return(found ? 0 : EINVAL);
726: }
727:
728: /*
729: * Processes involved in framebuffer mapping via GCSLOT are recorded in
730: * an array of pids. The first element is used to record the last slot used
731: * (for faster lookups). The remaining elements record up to GRFMAXLCK-1
732: * process ids. Returns a slot number between 1 and GRFMAXLCK or 0 if no
733: * slot is available.
734: */
735: grffindpid(gp)
736: struct grf_softc *gp;
737: {
738: register short pid, *sp;
739: register int i, limit;
740: int ni;
741:
742: if (gp->g_pid == NULL) {
743: gp->g_pid = (short *)
744: malloc(GRFMAXLCK * sizeof(short), M_DEVBUF, M_WAITOK);
745: bzero((caddr_t)gp->g_pid, GRFMAXLCK * sizeof(short));
746: }
747: pid = u.u_procp->p_pid;
748: ni = limit = gp->g_pid[0];
749: for (i = 1, sp = &gp->g_pid[1]; i <= limit; i++, sp++) {
750: if (*sp == pid)
751: goto done;
752: if (*sp == 0)
753: ni = i;
754: }
755: i = ni;
756: if (i < limit) {
757: gp->g_pid[i] = pid;
758: goto done;
759: }
760: if (++i == GRFMAXLCK)
761: return(0);
762: gp->g_pid[0] = i;
763: gp->g_pid[i] = pid;
764: done:
765: #ifdef DEBUG
766: if (grfdebug & GDB_LOCK)
767: printf("grffindpid(%d): slot %d of %d\n",
768: pid, i, gp->g_pid[0]);
769: #endif
770: return(i);
771: }
772:
773: grfrmpid(gp)
774: struct grf_softc *gp;
775: {
776: register short pid, *sp;
777: register int limit, i;
778: int mi;
779:
780: if (gp->g_pid == NULL || (limit = gp->g_pid[0]) == 0)
781: return;
782: pid = u.u_procp->p_pid;
783: limit = gp->g_pid[0];
784: mi = 0;
785: for (i = 1, sp = &gp->g_pid[1]; i <= limit; i++, sp++) {
786: if (*sp == pid)
787: *sp = 0;
788: else if (*sp)
789: mi = i;
790: }
791: i = mi;
792: if (i < limit)
793: gp->g_pid[0] = i;
794: #ifdef DEBUG
795: if (grfdebug & GDB_LOCK)
796: printf("grfrmpid(%d): slot %d of %d\n",
797: pid, sp-gp->g_pid, gp->g_pid[0]);
798: #endif
799: }
800:
801: /*ARGSUSED*/
802: grflckmapin(mp, off)
803: struct mapmem *mp;
804: {
805: u_int pa = kvtop((u_int)grf_softc[GRFUNIT(mp->mm_id)].g_locks);
806:
807: #ifdef DEBUG
808: if (grfdebug & GDB_LOCK)
809: printf("grflckmapin(%d): va %x pa %x\n", u.u_procp->p_pid,
810: grf_softc[GRFUNIT(mp->mm_id)].g_locks, pa);
811: #endif
812: return(pa >> PGSHIFT);
813: }
814:
815: grflckmmap(dev, addrp)
816: dev_t dev;
817: caddr_t *addrp;
818: {
819: struct proc *p = u.u_procp; /* XXX */
820: struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
821: struct mapmem *mp;
822: int error, grflckmapin();
823:
824: #ifdef DEBUG
825: if (grfdebug & (GDB_MMAP|GDB_LOCK))
826: printf("grflckmmap(%d): addr %x\n",
827: p->p_pid, *addrp);
828: #endif
829: if (gp->g_locks == NULL) {
830: gp->g_locks = (u_char *) cialloc(NBPG);
831: if (gp->g_locks == NULL)
832: return(ENOMEM);
833: }
834: error = mmalloc(p, minor(dev), addrp, NBPG, MM_RW|MM_CI,
835: &grflckops, &mp);
836: if (error == 0)
837: if (error = mmmapin(p, mp, grflckmapin))
838: (void) mmfree(p, mp);
839: return(error);
840: }
841:
842: grflckunmmap(dev, addr)
843: dev_t dev;
844: caddr_t addr;
845: {
846: register struct mapmem *mp;
847: int unit = minor(dev);
848:
849: #ifdef DEBUG
850: if (grfdebug & (GDB_MMAP|GDB_LOCK))
851: printf("grflckunmmap(%d): id %d addr %x\n",
852: u.u_procp->p_pid, unit, addr);
853: #endif
854: for (mp = u.u_mmap; mp; mp = mp->mm_next)
855: if (mp->mm_ops == &grflckops && mp->mm_id == unit &&
856: mp->mm_uva == addr) {
857: (void) grfexit(mp);
858: return(0);
859: }
860: return(EINVAL);
861: }
862: #endif /* HPUXCOMPAT */
863: #endif /* MAPMEM */
864: #endif /* NGRF > 0 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.