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