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